Einführung in Python

an
.
ge n 2
fla tho
Au Py
2. d e l t
h
Be
Moderne OO-Programmierung
5
Einführung in
Python
Mark Lutz & David Ascher
O’REILLY
Deutsche Bearbeitung und Aktualisierung
von Dinu C. Gherman
First
Inhalt
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Teil I
1
2
3
Max.
Linie
XV
Einleitung
Fragen und Antworten zu Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
Warum Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ist Python eine Skriptsprache? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wo ist der Haken? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wer benutzt heute Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Was kann ich mit Python machen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Welche technischen Stärken hat Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Python verglichen mit anderen Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
6
7
8
8
12
15
Programmausführung durch Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
Einführung in den Python-Interpreter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programmausführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Varianten des Ausführungsmodells . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
19
22
Wie man Python-Programme ausführt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
Interaktives Codieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
System-Kommandozeilen und Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Windows-Datei-Icons anklicken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Module importieren und neu laden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Entwicklungsumgebung IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Weitere IDEs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
33
37
41
45
49
Inhalt
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
| VII
Max.
Linie
Links
Eingebettete Aufrufe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eingefrorene ausführbare Binärdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Startmöglichkeiten im Texteditor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Weitere Startoptionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Qual der Wahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungen zu Teil I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
50
51
52
52
52
52
Teil II Typen und Operationen
4
5
Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
Python-Programmstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Warum eingebaute Typen benutzen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Python-Ausdrucksoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zahlen in Aktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Intermezzo: Dynamische Typisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
57
59
62
65
73
Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
String-Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Strings in Aktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
String-Formatierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
String-Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Generische Typenkategorien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6
7
Listen und Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Listen in Aktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dictionaries in Aktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tupel, Dateien und alles andere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Tupel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Typenkategorien, die Zweite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Allgemeinheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verweise und Kopien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Boolesche Wahrheitswerte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Max.
Linie
VIII
104
104
106
111
112
| Inhalt
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
120
123
124
126
126
128
130
Max.
Linie
Rechts
Vergleiche und Gleichheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Typenhierarchien in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Weitere Typen in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fallen bei eingebauten Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungen zu Teil II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
131
133
135
135
137
Teil III Anweisungen und Syntax
8
Zuweisungen, Ausdrücke und Print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Print-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
9
if-Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
if-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Python-Syntaxregeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Wahrheitstests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
10 while und for-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
while-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
break, continue, pass und das Schleifen-else . . . . . . . . . . . . . . . . . . . . . . . . . . .
for-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schleifenvarianten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
167
169
172
178
11 Python-Code dokumentieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Das Python-Dokumentationsintermezzo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Häufige Fallen beim Codieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Übungaufgaben zu Teil III . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Teil IV Funktionen
12 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Max.
Linie
Weshalb Funktionen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Codierung von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein erstes Beispiel: Definitionen und Aufrufe . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein zweites Beispiel: Schnittmenge von Sequenzen . . . . . . . . . . . . . . . . . . . . . .
203
204
207
209
Inhalt
| IX
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Links
13 Gültigkeitsbereiche und Argumente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Gültigkeitsregeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die global-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gültigkeitsbereiche und verschachtelte Funktionen . . . . . . . . . . . . . . . . . . . . . .
Argumentübergabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Spezielle Arten des Argumentabgleichs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
212
218
219
222
225
14 Funktionen für Fortgeschrittene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Anonyme Funktionen: lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Funktionen auf Argumente anwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Funktionen auf Sequenzen anwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Werkzeuge bei der funktionalen Programmierung . . . . . . . . . . . . . . . . . . . . . . .
Partielle Anwendung von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
List Comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dekoratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Generatoren und Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Konzepte beim Entwurf von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fallen bei Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungsaufgaben zu Teil IV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
235
239
242
243
244
245
249
251
255
258
262
Teil V Module
15 Module: Ein Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
Warum Module? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Architektur von Python-Programmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Funktionsweise eines Imports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
16 Grundlagen der Modulerzeugung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Erzeugung von Modulen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Benutzung von Modulen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Modulnamensräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Nachladen von Modulen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
278
279
283
288
17 Modul-Pakete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiele für Paket-Importe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wozu Paket-Importe? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Eine Geschichte von drei Systemen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Max.
Linie
X
| Inhalt
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
292
295
297
298
Max.
Linie
Rechts
18 Weiterführende Modul-Themen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
Datenkapselung in Modulen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zukünftige Sprachmerkmale aktivieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gemischte Verwendungsmodi: _ _name_ _ und _ _main_ _ . . . . . . . . . . . . . . .
Modulsuchpfad ändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Import-Erweiterung »as« . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Konzepte des Modulentwurfs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fallstricke bei Modulen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungsaufgaben zu Teil V . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
301
302
303
304
304
305
308
315
Teil VI Klassen und OOP
19 Objektorientierung in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Warum Klassen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
OOP aus 10.000 Meter Höhe betrachtet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
20 Grundlagen von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Klassen erzeugen mehrere Instanz-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Klassen werden durch Vererbung spezialisiert . . . . . . . . . . . . . . . . . . . . . . . . . . 334
Klassen können Python-Operatoren abfangen . . . . . . . . . . . . . . . . . . . . . . . . . . 337
21 Details der Klassenkodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Die class-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Operatorenüberladung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Namensräume: Die ganze Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
341
344
347
351
362
22 Design mit Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
Max.
Linie
Python und OOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Klassen als Datensätze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
OOP und Vererbung: »ist-ein« . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
OOP und Komposition: »hat-ein« . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
OOP und Delegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mehrfach-Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Klassen sind Objekte: Generische Objektfabriken . . . . . . . . . . . . . . . . . . . . . . .
Methoden sind Objekte: gebunden oder ungebunden . . . . . . . . . . . . . . . . . . . .
Wiederholung: Dokumentations-Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Klassen und Module im Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
369
371
372
374
378
380
383
385
387
388
Inhalt
| XI
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Links
23 Weiterführende Themen zu Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
Erweiterung eingebauter Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pseudo-private Klassenattribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Klassen »neuen Stils« in Python 2.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fallstricke bei Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungsaufgaben zu Teil VI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
390
394
396
404
407
Teil VII Ausnahmen und Werkzeuge
24 Grundlagen zu Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Warum Ausnahmen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ausnahmebehandlung: Die Kurzfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die try/except/else-Variante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die try/finally-Variante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die vereinheitlichte try/except/finally-Anweisung . . . . . . . . . . . . . . . . . . . . . . .
Die raise-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die assert-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
415
417
421
427
428
429
431
25 Ausnahme-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
Stringbasierte Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
Klassenbasierte Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
Allgemeine Formen der raise-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
26 Entwurf mit Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
Verschachtelte Ausnahme-Behandler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Code-Idiome zu Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tipps zum Entwurf mit Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fallstricke bei Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung zum Sprachkern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungsaufgaben zu Teil VII . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
444
448
451
455
456
461
Teil VIII Die Hülle
27 Typische Aufgaben in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
Max.
Linie
Konvertierung, Zahlen und Vergleiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
Manipulation von Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
XII |
Inhalt
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Rechts
Modifikation von Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Bearbeiten von Dateien und Verzeichnissen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Internet-bezogene Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ausführung von Programmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fehlersuche, Testen, Zeitmessung, Optimierung . . . . . . . . . . . . . . . . . . . . . . . .
Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
479
486
501
505
508
511
28 Frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
Ein automatisches Beschwerdesystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verbindung mit COM: Billige Öffentlichkeitsarbeit . . . . . . . . . . . . . . . . . . . . .
Ein auf Tkinter basierender GUI-Editor zum Bearbeiten von Formulardaten . .
Jython: Die glückliche Ehe zwischen Python und Java . . . . . . . . . . . . . . . . . . .
Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
514
520
526
533
541
29 Python-Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
Verschiedene Ebenen der Gemeinschaft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Entwicklungsprozess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dienstleistungen und Produkte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der juristische Rahmen: Die Python Software Foundation . . . . . . . . . . . . . . . .
Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beliebte Software von Drittanbietern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Webanwendungs-Frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Werkzeuge für Python-Entwickler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
542
547
547
547
548
549
559
561
Teil IX Anhang
A
Installation und Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
B
Lösungen zu den Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
Max.
Linie
Max.
Linie
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Inhalt |
XIII
First
Kapitel 1
KAPITEL 1
Fragen und Antworten zu Python
Wenn Sie dieses Buch gekauft haben, dann wissen Sie vielleicht schon, was Python ist,
und warum es eine wichtige Sprache ist, die man lernen sollte. Falls nicht, dann werden
Sie wahrscheinlich erst von Python begeistert sein, wenn Sie die Sprache nach der Lektüre dieses Buches gelernt und Erfahrung in ein oder zwei Projekten damit gesammelt
haben. Bevor wir auf Details eingehen, möchten wir ein paar Seiten darauf verwenden,
Ihnen kurz einige der Hauptgründe für die Popularität von Python vorzustellen. Um eine
Definition von Python zu entwickeln, nimmt dieses Kapitel die Form einer Frage- und
Antwortsitzung an, in der einige der von Anfängern am häufgisten gestellten nichttechnischen Fragen behandelt werden.
Warum Python?
Da es heute viele Programmiersprachen gibt, ist das häufig die erste Frage, die gestellt
wird. Es kann darauf keine exakte, befriedigende Antwort geben, da Python von vielen
Hunderttausenden Benutzern verwendet wird. Die Wahl der Entwicklungsumgebung
erfolgt dabei oft unter ganz speziellen Gesichtspunkten und persönlichen Vorlieben.
Aber nachdem wir Python in den letzten Jahren über tausend Studenten beigebracht und
in über hundert Firmen eingeführt haben, konnten wir einige häufige Gründe herauskristallisieren. Zu den wichtigsten Gründen, die von Python-Benutzern genannt werden,
gehören:
Max.
Linie
Software-Qualität
Für viele ist es die Ausrichtung auf Lesbarkeit, Kohärenz und Software-Qualität im
Allgemeinen, die Python von Sprachen wie Perl unterscheidet, die verschiedene Konzepte mischen. Anders als traditionellere Skriptsprachen wurde Python so entworfen, dass Code lesbar und damit auch wartbar ist. Außerdem unterstützt Python seit
jeher Mechanismen zur Wiederverwendung von Software, z.B. die objektorientierte
Programmierung (OOP).
| 3
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Links
Entwickler-Produktivität
Python steigert die Produktivität von Entwicklern um ein Vielfaches, verglichen mit
kompilierten oder statisch typisierten Sprachen wie C, C++ und Java. Python-Code
ist in der Regel 1/3 bis 1/5 so lang wie äquivalenter Code in C++ oder Java. Also gibt
es weniger Code zu tippen, zu debuggen und zu warten, nachdem er fertig ist. Außerdem sind Python-Programme sofort ausführbar, ohne langes Kompilieren und Linken wie bei einigen anderen Sprachen.
Programm-Portabilität
Die meisten Python-Programme laufen unverändert auf den wichtigsten Rechnerplattformen. So besteht z.B. die Portierung von Python-Code zwischen Unix and
Windows meist nur aus dem Kopieren der Skriptdatei zwischen den Rechnern.
Außerdem bietet Python mehrere Möglichkeiten für die Entwicklung portabler grafischer Benutzeroberflächen.
Bibliotheksunterstützung
Python enthält eine große Sammlung an vorgefertigter, portabler Funktionalität in
seiner Standardbibliothek. Sie bietet Unterstützung bei vielen Aufgaben der Anwendungsprogrammierung, z.B. Textmustererkennung oder Netzwerkkommunikation.
Und Python kann sowohl mit selbst geschriebenen Bibliotheken als auch mit einer
riesigen Anzahl von Programmen für die Anwendungsentwicklung von Dritten erweitert werden.
Komponenten-Integration
Python-Skripte können sehr leicht über eine Vielzahl von Integrationsmechanismen
mit anderen Teilen einer Anwendung kommunizieren. Dadurch kann man Python
zur Anpassung und als Erweiterungswerkzeug bei anderen Produkten verwenden.
Heute kann Python-Code C- und C++-Bibliotheken aufrufen, kann von C- und
C++-Programmen aufgerufen werden, kann mit Java-Komponenten interagieren,
über COM, Corba und .NET kommunizieren, und mit Schnittstellen wie SOAP und
XML-RPC über Netzwerke hinweg interagieren.
Freude am Entwickeln
Da Python so einfach zu benutzen ist und viele Werkzeuge mitbringt, kann es das
Programmieren zu einer vergnüglichen Tätigkeit statt einer langweiligen Beschäftigung machen. Auch wenn dieser Vorteil wenig greifbar ist, hat er einen wichtigen
Einfluss auf die Produktivität insgesamt.
Die ersten beiden Gründe auf dieser Liste, Qualität und Produktivität, sind für die meisten
Python-Entwickler vermutlich die dominierenden.
Software-Qualität
Max.
Linie
Python wurde so entworfen, dass es sowohl eine einfache und leicht lesbare Syntax als
auch ein höchst kohärentes Programmiermodell hat. Der Slogan einer vergangenen
Python-Konferenz brachte das auf den Nenner, man habe den Eindruck, dass Python
4 | Kapitel 1: Fragen und Antworten zu Python
Max.
Linie
Rechts
»zum menschlichen Gehirn passt« (»Python fits your brain«). Das heißt, die Eigenschaften der Sprache interagieren auf konsistente und definierte Weise miteinander und ergeben sich auf natürliche Weise aus einer kleinen Menge von Kernkonzepten. Dadurch
kann man die Sprache leichter erlernen, verstehen und behalten. In der Praxis müssen
Python-Programmierer nicht ständig Handbücher lesen, wenn sie Code schreiben oder
lesen, da die Sprache orthogonal entworfen wurde.
Zur Philosophie von Python gehört, dass es einen leicht minimalistischen Ansatz verfolgt.
Auch wenn also eine Codierungsaufgabe durchaus auf mehrere Arten gelöst werden
kann, so gibt es normalerweise nur eine, die offensichtlich ist, einige weniger offensichtliche Alternativen sowie einen kleinen Satz an kohärenten Interaktionen in der gesamten
Sprache. Außerdem führt Python keine eigenmächtigen Entscheidungen an Ihrer Stelle
aus. Wenn es mehrdeutige Interaktionen gibt, dann wird auf explizite Intervention statt
auf »Magie« gesetzt. In der Python-eigenen Denkweise ist explizit besser als implizit und
einfach ist besser als kompliziert.1
Neben solchen Entwurfsleitlinien enthält Python Mechanismen wie Module und OOP,
was die Code-Wiederverwendung auf natürliche Weise unterstützt. Und da Python auf
Qualität setzt, tun das natürlich auch Python-Programmierer.
Entwickler-Produktivität
Während des großen Internet-Booms Mitte bis Ende der 1990er-Jahre war es schwierig,
genug Programmierer für Software-Projekte zu finden. Die Entwickler sollten Systeme
genauso schnell implementieren, wie sich das Internet entwickelte. In der darauf folgenden Zeit von Entlassungen und wirtschaftlicher Rezession hat sich das Bild verändert.
Heute müssen die Entwicklungsabteilungen die gleichen Aufgaben mit weniger Angestellten durchführen.
In beiden Szenarien hat sich Python als Werkzeug bewährt, das es dem Programmierer
ermöglicht, mit weniger Aufwand mehr zu erreichen. Es optimiert absichtlich die Entwicklungsgeschwindigkeit. Dank der einfachen Syntax, der dynamischen Typisierung, der fehlenden Kompilierung sowie den eingebauten Werkzeugen können Python-Programmierer
ihre Programme in einem Bruchteil der Zeit entwickeln, die bei einigen anderen Sprachen
nötig ist. Im Endeffekt steigert Python normalerweise die Entwickler-Produktivität um ein
Vielfaches, verglichen mit traditionellen Sprachen. Und das ist immer eine gute Nachricht,
ob die Wirtschaft nun rauf- oder runtergeht.
Max.
Linie
1 Einen weiteren Überblick zur Python-Philosophie erhalten Sie, wenn Sie bei einer interaktiven Python-Eingabeaufforderung den Befehl import this eingeben (in Kapitel 2 erfahren Sie, wie). Das ruft ein in Python verstecktes
Osterei auf und gibt die gesammelten Python-Entwurfsprinzipien aus.
Warum Python?
| 5
Max.
Linie
Links
Ist Python eine Skriptsprache?
Python ist eine universelle Programmiersprache, die oft als Skriptsprache verwendet
wird. Häufig definiert man sie als objektorientierte Skriptsprache, eine Definition, die ihre
Ausrichtung auf OOP und den Skriptbereich hervorhebt. Tatsächlich spricht man oft von
einem »Skript« statt von einem »Programm«, wenn es um eine Datei mit Python-Code
geht. In diesem Buch werden die Begriffe »Skript« und »Programm« synonym zueinander
benutzt. Dabei wird »Skript« leicht bevorzugt, wenn es um eine einzelne einfache Datei
geht, und »Programm«, wenn eine höher entwickelte Anwendung aus mehreren Dateien
gemeint ist.
Da der Begriff »Scripting« für viele Leute ganz unterschiedliche Bedeutungen hat, möchten ihn einige überhaupt nicht auf Python anwenden. Tatsächlich denken die Leute an
drei sehr verschiedene Definitionen, wenn sie Python mit dem Begriff »Skriptsprache«
assoziieren, die unterschiedlich gut zutreffen:
Shell-Werkzeuge
Shell-Werkzeuge sind Werkzeuge für die Codierung von betriebssystemnahen Skripten. Solche Programme werden meist in einer Konsole von der Kommandozeile aus
gestartet und verarbeiten oftmals Textdateien und/oder starten weitere Programme.
Python-Programme können das auch, aber das ist nur einer von Dutzenden üblichen
Anwendungsbereichen von Python-Anwendungen. Python ist nicht einfach nur eine
bessere Shell-Skriptsprache.
Steuersprache
Eine Steuersprache ist ein »Klebstoff« zum Steuern und Dirigieren (also Skripten)
anderer Anwendungskomponenten. Tatsächlich werden Python-Programme oft zusammen mit einer großen Anwendung ausgeliefert. Um z.B. ein Hardware-Gerät zu
testen, können Python-Programme Komponenten aufrufen, die einen Low-LevelZugriff auf das Gerät ermöglichen. Oder Programme können Python-Code an strategischen Stellen ausführen, um ein Produkt durch den Endbenutzer anzupassen, damit
nicht der gesamte Quellcode des Systems ausgeliefert und neu kompiliert werden
muss. Die Einfachheit von Python macht es zu einem ganz natürlichen, flexiblen Steuerungswerkzeug. Aber technisch betrachtet ist das lediglich eine der Rollen, die Python
häufig einnimmt. Viele Python-Programmierer schreiben einzelne Skripte, ohne
jemals irgendwelche integrierten Komponenten zu benutzen oder auch nur zu kennen.
Max.
Linie
Einfache Anwendung
Bei dieser Definition ist eine Skriptsprache eine einfache Sprache zum schnellen
Codieren von Aufgaben. Vielleicht ist das die beste Art, sich Python als Skriptsprache
vorzustellen. Mit Python kann man Programme wesentlich schneller entwickeln als
mit kompilierten Sprachen wie C++. Der schnelle Entwicklungszyklus unterstützt
eine explorative, inkrementelle Art von Programmierung, die man erleben muss, um
sie wertschätzen zu können. Aber täuschen Sie sich nicht: Python ist nicht nur für
einfache Aufgaben geeignet. Vielmehr vereinfacht es die Aufgaben durch seine leichte
6 | Kapitel 1: Fragen und Antworten zu Python
Max.
Linie
Rechts
Anwendbarkeit und Flexibilität. Python verfügt über einfache Eigenschaften, macht
es Programmen aber leicht, bei Bedarf zu skalieren und sich weiterzuentwickeln.
Ist Python also eine Skriptsprache oder nicht? Das kommt darauf an, wen Sie fragen. Im
Allgemeinen beschreibt der Begriff Scripting vermutlich am besten die schnelle und flexible Art der Entwicklung, die Python unterstützt, und weniger einen bestimmten
Anwendungsbereich.
Wo ist der Haken?
Der einzige Nachteil von Python ist vielleicht der, dass in der aktuellen Implementierung
die Ausführungsgeschwindigkeit nicht immer genauso hoch ist wie bei kompilierten
Sprachen wie C und C++.
Wir behandeln Implementierungskonzepte noch in diesem Buch. Hier nur ganz kurz
dazu: Standardimplementierungen von Python kompilieren (d.h. übersetzen) QuellcodeAnweisungen heute in ein Zwischenformat namens Bytecode und interpretieren dann diesen Bytecode. Der Bytecode sorgt für Portabilität, da er in einem plattformunabhängigen
Format vorliegt. Aber da Python nicht vollständig zu binärem Maschinencode (z.B. zu
Anweisungen für einen Intel-Chip) kompiliert wird, laufen manche Programme langsamer in Python als in einer vollständig kompilierten Sprache wie C.
Ob Ihnen der Unterschied in der Ausführungsgeschwindigkeit jemals etwas ausmacht, ist
eine andere Sache und hängt davon ab, was für Programme Sie schreiben. Python wird
immer weiter optimiert, und Python-Code für sich allein genommen ist in den meisten
Anwendungsbereichen schnell genug. Außerdem gilt, dass wann immer Sie in einem
Python-Skript »wirklich etwas machen«, z.B. eine Datei verarbeiten oder eine GUI erzeugen, Ihr Programm tatsächlich mit der Geschwindigkeit von C läuft, da solche Aufgaben
sofort von kompiliertem C-Code im Python-Interpreter übernommen werden. Grundsätzlich gilt, dass die Steigerung der Entwicklungsgeschwindigkeit durch Python oftmals
weitaus wichtiger ist als jeder Verlust an Ausführungsgeschwindigkeit, besonders bei der
Geschwindigkeit moderner Rechner.
Sogar für heutige CPU-Geschwindigkeiten gibt es aber Bereiche, die nach der optimalen
Ausführungsgeschwindigkeit verlangen. In der numerischen Programmierung und Animation benötigen oft mindestens die zahlenfressenden Kernkomponenten die Geschwindigkeit von C (oder noch mehr). Auch wenn Sie in solchen Bereichen arbeiten, können Sie
Python einsetzen. Sie müssen lediglich die Teile der Anwendung, die höchste Geschwindigkeit benötigen, in kompilierte Erweiterungen abspalten und mit Ihrem System linken,
damit Sie sie in Python-Skripten benutzen können.
Max.
Linie
Erweiterungen sind nicht das Hauptthema in diesem Buch, aber auch das ist nur ein weiterer Fall von Python-als-Steuersprache, eine Rolle, die weiter oben angesprochen wurde.
Ein herausragendes Beispiel dieser Zweisprachen-Strategie ist NumPy, eine PythonErweiterung für die numerische Programmierung. Durch die Kombination von kompilier-
Wo ist der Haken?
| 7
Max.
Linie
First
Index
Symbole
%-Operator (Rest/Format) 63
&-Operator (bitweises Und) 63
*-Operator (Multiplikation) 63, 338
+-Operator (Addition/Verkettung) 338
... Eingabeaufforderung 179
/-Operator (Division) 63
: (Doppelpunkt) 160
== (Vergleichsoperator) 131
>> (Shift-Operator) 63
>>> (Eingabeaufforderung) 30
^-Operator (bitweises Exklusiv-Oder) 63
_ _add_ _-Methode 352
_ _dict_ _-Attribute 283–284
_ _getattr_ _-Methode 357
_ _getitem_ _-Methode 353
_ _init_ _.py-Dateien 293
_ _init_ _-Konstruktor 338, 344, 349
_ _repr_ _-Methode 358
{ } (geschwungene Klammern) 112
|-Operator (bitweises Oder) 63
’ (Anführungszeichen) für Strings 81
A
Max.
Linie
Abbildung 111
Funktionen 242
abfangen
Ausnahmen 453, 456
benutzerdefinierte Ausnahmen 430
eingebaute Ausnahmen 426
Abfangen von Beschränkungen 432
Ablaufverfolgung 26
abs-Funktion 471
abstrakte Oberklassen 350
allgemeine Mengen-Funktionen 232
Allgemeingültigkeit, Qualifikation 285
and-Operator 63, 164
Anpassung
Dictionaries 114
IDLE 48
Klassen 334–337
Sortierung 483
Texteditoren 52
Vererbung 320
Anweisungen
assert 431
Ausdrücke 151
Begrenzungszeichen 162
definierte 143
Fehlersuche 196
if 157–160
print 32, 152–155
raise 429–431
Reihenfolge der 310
Syntax 160–164
try/except/else 421–428
try/finally 427
try/finally-Endebehandlung 428
Verbund- 32
verpacken 451
Wahrheitstests 164
while 167–169
Zusammenfassung 144
Zuweisung 144, 149, 151, 281
Anwendungen, Internationalisierung von 87
| 609
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Links
Max.
Linie
append-Methode 109, 114, 485
apply-Funktion 239–241
Architektur 268–271
Argumente 206
Änderungen an veränderlichen 223
apply-Funktion 239–241
gemeinsame Verweise 223
Matching 225, 233
Standardwerte 260
Übergabe 222, 232, 234, 241
Argumentübergabe beim Referenzaufruf 225
argv-Attribut (sys-Modul) 93
Arrays 107
Aspektorientierte Programmierung 26
assert-Anweisung 431
Attribute 41
Architektur 269
Klassen 404
Konstruktion 347
pseudoprivate Klasse 394–396
Qualifikation 285
Suche bei der Vererbung 321
Aufgaben, Lösungen zu den 572
Aufrufe
apply-Funktion 241
einbetten 50–51
eingebaute String-Methoden 98
Funktionen 207
indirekte 257
Instanzen 360
Klassen 332
Listenmethoden 109
Methoden 346
Oberklassen-Konstruktoren 346
Signaturen 370
Ausdrücke 62–64, 151
Funktionen, Methoden 151
gemischte Typen 64
häufige 151
Klammern 63
Lambdas 236
List-Comprehension 245–249
Literale 59
Operatoren überladen 64
Werte ausgeben 151
Zahlen 65–73
ausführbare Skripte 36
eingefrorene Binärdateien 51
610 | Index
ausführen
interaktive Kodierung 29–32
Moduldateien 33–37
Ausführung 19–22
Code 505–508
innerhalb des Prozesses 450
Modellvariationen 22
Moduldateien 276
PVM 21
Sequenzen 160
Texteditoren 52
Ausgabe
Funktionen 204–211
Ausgabeströme
modifizieren 494
umlenken 154
Ausnahmen 415–421
abfangen 453, 456
assert-Anweisung 431
äußeres try 449
benutzerdefinierte (Beispiel) 430
eingebaute abfangen (Beispiel) 426
Fehlersuche 448–451
Klassen 434–442
Matching 455
raise-Anweisung 429–431
raw_input 448
Strings 433
Suchroutine 448
testen 452
Text 439
try/except/else-Anweisung 421–428
try/finally-Anweisung 427
verschachteln 444–448, 451–455
zusätzliche Daten übergeben 430
auspackende Zuweisungen 145
äußere try-Anweisungen 449
Auswahl von Modulen 274
automatische Erweiterungen, Windows 35
automatische Speicherverwaltung 14
B
Backslash 83, 163
Bäume 324, 347
Begrenzungszeichen
Anweisungen 162
Blöcke 161
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Rechts
benutzerdefinierte Ausnahmen abfangen 430
benutzerdefinierte Dokumentations-Strings 186
benutzerdefinierte Iteratoren 355
Bereiche
Schleifen 178
Zeichenlisten 181
Berichte, PyDoc 189, 192
Beschränkungen 7
abfangen 432
Icon-Klicks 40
betrachten 40
Betrachtung 67
Betriebssysteme, automatische Erweiterungen
35
Beziehungen, Vererbung/OOP 372–378
Bildschirm löschen in IDLE 48
Binärdateien 499
bitweise Operatoren 63, 69
bitweises Shift, Zahlen 69
Blöcke
Begrenzungszeichen 161
-Strings 86
Blockgröße auswählen 497
Boolesche Operatoren 164
Zahlen 69
break-Anweisung 169
Bytecode 7
Escape-Sequenzen 82
kompilieren 20
C
C
Max.
Linie
Integration mit 14
Zuweisungen 173
C++ 10, 14
Callback-Funktionen 240
gebundene Methoden 388
CGI (Common Gateway Interface)
Module 501
Skripte 514, 532
chr-Funktion 471, 473
class-Anweisung 341
close-Funktion 125
cmp-Funktion 472
Code
Architektur 268–271
ausführen 505–508
Ausnahmen 433–442
C, Python und 196
Dokumentation 184–195
einbetten 50–51
Endebehandlung 428
Escape-Sequenzen 82
Fehlersuche 196
Funktionen 204–211
hello world 153
hexadezimale Notation 72
IDLE 47
interaktiver 29–32
Klassenbäume 324
Kommentare 65
kompilieren 20
Modell für dyn. Typisierung 74–79
Module 268, 278–282
Namen 212–218
oktale Notation 72
OOP 321–329
Spalte 1 196
Strings 94–97
testen 31
Unterausdrücke 63
Verwendungshinweise 44
Werkzeuge 243
Wiederverwendung 203, 326
(siehe auch Module)
COM (Microsoft Common Object Model) 474,
481
COM-Framework 513, 521
formletter.py 521
Information finden über 525
Common Gateway Interface (siehe CGI)
compile-Funktion 505
complex-Funktion 473
Constraint-basierte Programmierung 26
continue-Anweisung 169
CPython 22
csh-Shell 569
D
Dateien 124–126
ausführen 19
auswählen 274
Erweiterungen 35
Gültigkeitsbereich 216
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Index |
611
Links
Max.
Linie
kopieren 490
Matching 492
Namensänderungen an mehreren 282
print-Anweisungen in 35
Scanner-Schleifen 177
verarbeiten 125
Verarbeitung 495
Dateimanipulation
glob-Modul 492
Menge von Dateien, Kommandozeile 498
open- und close-Funktionen 124
temporäre Dateien 493
Dateinamensmanipulation 491
Daten in Modulen verbergen 301–304
Datenbanken 10
Datenkapselung 301–304
Datensätze
Dictionaries 118
Klassen als 371–372
Datenstrom-Prozessoren 376
Datenstrukturmanipulation 479–485
def-Anweisung 204–205
zur Laufzeit 206
Deklaratoren 249
del-Anweisung 105, 110, 114, 138
Delegation und OOP 378
Destruktoren 361
diamantförmige Vererbung 397
Dictionaries 111–112
an Indices zuweisen
Datensätze 371–372
erzeugen 183, 485
häufige Konstanten, Operationen 112
kopieren 480
Namensräume 364
Operationen 112–115
Schlüssel 116
Sequenzoperationen 116
Sprachtabellen 115
sys.modules 306
sys.path 304
verändern 114
Verwendungshinweise 116
dir-Funktion 185, 466
Division 68
Dokumentation 184–195
COM 525
Strings 387, 388
612 | Index
Dokumentations-Strings 186
eingebaute 188
Standards 188
Doppelpunkte, Verbundanweisungen 196
dynamische Typisierung 12, 13, 74–79
E
Edit/Runscript-Option (IDLE) 48
editieren (siehe Texteditoren)
Effizienz eingebauter Objekte 58
einbetten
Objekte 390
Python in C 10
Sequenzen 82
einfache Variablen 285
Eingabe modifizieren 494
Eingabeaufforderungen
... 32
>>> 30
Dateierweiterungen 35
einrücken 32
interaktive 32
Verbundanweisungen 32
eingebaute apply-Funktionen 239
eingebaute Ausnahmen
abfangen 426
Klassen 438
eingebaute Dokumentations-Strings 188
eingebaute Funktionen 508
Zahlwerkzeuge 73
eingebaute Module
Binärdateien 499
cgi-Modul 501
Fehlerbeseitigung 508
Internet-Datenverarbeitung 503
Internet-Protokolle 503
Laufzeitprofil 510
string-Funktionen 474
string-Konstanten 474
time-Modul 509
urllib 502
urlparse 503
eingebaute Objekttypen 59
eingebaute String-Methoden 98
eingebaute Typen 57–59
erweitern 390–394
Fehlersuche 135–137
Hierarchien 133–134
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Rechts
Max.
Linie
Iteratoren 254
Kategorien 126
eingebaute Werkzeuge 61
eingebauter Gültigkeitsbereich 217
eingefrorene Binärdateien 27
ausführbare 51
Einrückung 161, 196
interaktive Eingabeaufforderungen 32
einstellige Operatoren 63
elif-Klausel 157
else (Schleifen) 157, 168–169, 174
else-Anweisung 421
Endebehandlung 416, 418, 428
Endungen
komplexe Zahlen 71
(siehe auch Erweiterungen)
Entwickler-Produktivität 5
Entwicklung 21
Entwicklungsgeschwindigkeit 5
Entwurf
Ausnahmen 444–455
Entwurfsmuster 329
Funktionen 255–258
Module 305–308
OOP 369
Ereignismeldung 416
erneutes Modul-Laden 288
allgemeine Form 288
Attribute 42–44
Auswirkung auf Importe 312
Beispiel 289
Verwendungshinweise 44
erweiterte Zuweisungsanweisungen 149
Erweiterungen 7
automatische (Windows) 35
Bytecode 20
eingebaute Objekte 58
Importe als 304
Klassen neuen Stils 400
print-Anweisungen 154
Zahlen 61
Escape-Sequenzen 82
eval-Funktion 505
exec-Anweisung 505
execfile-Funktion 505–506
explizite Konfliktauflösung 398
extending
Python mit C 14
Extensible Markup Language (siehe XML)
F
Fabriken 383
feedback.py-Programm 514–520
Fehlerbehandlung 416
Fehlerbeseitigung 425, 448, 508–511
äußere try-Anweisungen 449
IDLE 48
Module 508
(siehe auch Fehlersuche)
Fehlersuche 508–511
Änderungen an veränderlichen Argumente
223
Ausnahmen 415–421, 429–431, 448–451
Code 196
explizite Konfliktauflösung 398
Funktionen 258–262
Icon-Klicks 40
if-Anweisugnen 158
Klassen 404–407
Module 308–315
Objekte 135–137
Wahrheitswerte 164
Fenster, IDLE 47
Fließkomma-Literale 60
Fließkommazahlen 59
float-Funktion 470, 473
Formatierung 212–218
Dictionaries 183, 485
for-Schleifen 173
Funktionen 204–211, 255–258
if-Anweisungen 157
Listen 485
Module 305–308
Schleifen 169–173
Strings 94–97
FormEditor-Program
Vergleich mit feedback.py 532
FormEditor-Programm 526
add_variable 530
Code 527
for-Schleifenblock 529
load_data-Funktion 530–531
select-Methode 531
formletter.py-Programm 521
Formulare, print-Anweisungen 152
for-Schleife 172–177
Variationen 178–183
Frameworks 329, 513
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Index |
613
Max.
Linie
Links
COM 520–525
Entwurfsüberlegungen 532
PIL 553
Swing Java GUI 534–541
Freeware 12
from-Anweisung 279, 281
allgemeine Form 288
for-Zuweisungen 281
interaktives Testen 312
Module 309
Pakete 296
Zuweisungen 281
Funktionen 203, 235
Abbildung 242
allgemeine Menge 232
apply-Funktion 239–241
Argumentübergabe 222, 234
Aufrufe 207
Aufrufsyntax 197
Callback 240
Code 204–211
Code-Wiederverwendung 203
dir 185
eingebaute 508
Entwurf 255–258
Ergebnisse 197
Fehlersuche 258–262
Generatoren 251–255
global-Anweisung 205, 218
Gültigkeitsregeln in 212
indirekte Aufrufe 257
Iteratoren 251–255
Lambdas 235–239
map-Funktion 242
partielle Anwendung 244
Python-Code ausführen 505–508
raw_input 39, 448
return-Anweisung 205
reversed-Funktion 180
Typkonvertierungen 472
überladen 370
überschneidende Elemente 209
umgebende 214
verschachteln 219–222
Werte 231
Zahlwerkzeuge 73
Max.
Linie
614 | Index
G
Ganzzahlen 60, 70
lange 70
Literale 60
Zuweisungen 74
gebundene Instanzmethoden 385
gemeinsame Objektverweise 128
gemeinsame Verweise 128–130, 223
gemischte Operatoren 62
gemischte Typen, Ausdrucksoperatoren 64
gemischte Verwendungsarten, Module 303
Generator-Ausdrücke 254
Generatoren 251–255
Generierung
mehrerer Instanzobjekte 330–334
von Instanzen 371
generische Datenstrom-Prozessoren 376
Gleichheit, testen auf 131–133
global deklariert 214
global-Anweisung 205, 218
globaler Gültigkeitsbereich 213
glob-Modul 492
grapher.py 535, 540
Graphical User Interface (siehe GUI)
Groß-/Kleinbuchstaben-Unterscheidung
Namen 147
Größe von Objekten 89
große Zeichenmengen kodieren 86
GUI (Graphical User Interface)
Entwurfsüberlegungen 532
Programmierung 9
Gültigkeitsbereich 179, 362, 379
eingebauter 217
importieren 286
Lambdas 238
LGB-Regel 214
Regeln 212–218
verschachteln 206
verschachtelte Funktionen 219–222
(siehe auch Namensräume)
H
Hammond, Mark 521
»hat-eine«-Beziehung 374
hello world ausgeben 153
hexadezimale Konstanten 61
hexadezimale Literale 60
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Rechts
hexadezimale Notation 72
hex-Funktion 473
Hierarchien
Klassen 334
Objekte 133–134
HTML (Hypertext Markup Language) 9, 515
PyDoc-Berichte 192
Hypertext Markup Language (siehe HTML)
I
Max.
Linie
Icons, Windows- 37–41
Identitätstests 131
IDLE 45–49
if-Anweisungen 157–160
imaginäre Zahlen 71
Implementation 22
import-Anweisung 505
allgemeine Form 288
als Zuweisung 281
importieren
Äquivalenz 282
Architektur 269
Attribute 42–44
Erweiterungen 304
Gültigkeitsbereich 286
Module 41–42, 271–277, 279–280
Namensstrings 308
Pakete 292–300
rekursiv 311
Verwendungshinweise 44
Zuweisungen 281
IndexError-Ausnahme 418
indirekte Aufrufe 257
indizieren 80, 90, 91
_ _getitem_ _-Methode 353
Dictionaries (siehe Dictionaries)
Klassen 353
Listen 104–110
in-Operator 63
Installation 18
Instanzen 371
Aufrufe 360
Klassen 322
mehrere -objekte 330–334
Slots 400
zusätzliche Daten schicken 440
Integration
mit C 10, 14, 51
Komponenten 10
Integrität, Tupel 123
interaktive Eingabeaufforderungen
einrücken 32
Kommandos 32
interaktive Kommandozeile, Python 29
interaktive Sitzungen 41
interaktives Testen 312
Internationalisierung von Anwendungen 87
Internet
cgi-Modul 501
Datenverarbeitung 503
Hilfsmodule 9
Protokolle 503
urllib-Modul 502
urlparse-Modul 503
Internet-Module 501–504
Interpreter nutzen 17
int-Funktion 470, 473
Introspektion 306
IronPython 23
is not-Operator 63
is-a-Relation 372
is-Operator 63, 131
Iteration 167–169, 242
benutzerdefinierte 355
Klassen 354
Strings 89
J
Java/Jython 533
Java-Bibliotheken 534
Java-Scripting 535
Nnstallation 533
Swing-Anwendung, grapher.py 535
Vergleich 540
Jython 23
K
Kanäle 495
Kapselung 369
Kategorien
Ausnahmen 434
Typen 126
KI-Programmierung 11
Klammern in Ausdrücken 63
Klassen
_ _add_ _-Methode 352
_ _getattr_ _-Methode 357
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Index |
615
Links
Max.
Linie
_ _getitem_ _-Methode 353
_ _init_ _-Konstruktor 338, 344, 349
_ _repr_ _-Methode 358
aufrufen 332
Ausnahmen 434–442
Bäume 324
als Datensätze 371–372
Dokumentations-Strings 387
entwerfen mit OOP 369
Fehlersuche 404–407
generische Objektfabriken 383
Gründe für 320
Instanzen 322
Iteration 354
mehrfache Instanzobjekte 330
Methoden 344, 400
Module 336, 388
Namensräume 362–368
Namensverstümmelung 394
neuer Stil 396, 404
Oberklassen 334
Operatorüberladung 127, 337, 340, 351
Persistenz 379
Properties 401
pseudoprivate Attribute 394–396
Schnittstellen 349
Unterklassen 334–337
Vererbung 334–335, 383
Klassen neuen Stils 396, 404
klassifizierende Namen 363
Klauseln
try/else 424
try-Anweisung 422
Kommandos, interaktive Eingabeaufforderungen 32
Kommandozeilenargumente 29–32, 93
Kommentare 65, 160
Dokumentation 185
kommutative Operatoren 359
Komodo 50
kompilieren
Bytecode 20
Erweiterungen 7
Module 276
Psyco, Just-in-Time-Compiler 24
komplexe Zahlen 61, 71
Komponenten
Integration 10
mischen 27
616 | Index
Psyco, Just-in-Time-Compiler 24
PVM 21
Komposition 320, 374
Konfiguration
Ausnahmen 444–455
Dictionaries 112–115
Funktionen 255–258
Module 305–308
Suchpfad-Einstellungen 293
Konfliktauflösung 398
Konstanten
Listen 105
Tupel 121
Konstruktoren 326
Klassen 338, 344, 346, 349
Kontrollfluss
Anweisungen 160
ungewöhnlicher 417
verschachteln 445
Konventionen, Namens- 148, 485
Konvertierung, Strings 64, 92–95, 470–474
Konzepthierarchie 143
kopieren
copy-Modul 481
Dateien 490
Dictionaries 480
Objekte 128–130, 479
Vergleich mit verweisen 145
Verzeichnisse 490
Kopplung 255
ksh-Shell 569
Kurzschlussauswertung 165
L
Lambdas 235–239
Operatoren 63
lange Ganzzahlen 60, 70, 470
Laufzeit, def-Anweisungen 206
Laufzeitmessung 508–511
Laufzeitprofil 508–511
lazy evaluation 26
leere Sequenzen 132
leere Strings 80
Leerzeichen in Programmen 160
Leerzeilen 196
LEGB-Regel 214–215
leichte Bedienung 15
len-Funktion 89
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Rechts
lesen von stdin 498
lexikalische Gültigkeitsbereiche 286
Links, Namensräume 367
List-Comprehension-Asdrücke 245–249
Listen
an Ort und Stelle ändern 108
Dictionaries 116
einfache Operationen auf 106
erzeugen 485
häufige Konstanten 105
Indizierung und Slicing 107
Methoden 109
Objekte 131–133
Operationen 106
sys.path 274
Tupel 123
Zeichen 181
list-Funktion 472
Literale 59
Dictionaries 112
Fließkomma 60
Listen 105
Strings 81–88
Tupel 121
Zahlen 60
logisch falsche Objekte 132
logische Operatoren 63
logische Programmierung 26
lokale Variablen 211
lokaler Gültigkeitsbereich 213
long, C 470
long-Funktion 473
Lösungen zu den Aufgaben 572
Lundh, Fredrik 553
M
Max.
Linie
Manuale (siehe Dokumentation)
map-Funktion 181, 242
Matching
Argumente 225, 233
Ausnahmen 455
Dateien 492
Matritzen 107
max-Funktion 474
mehrdimensionale Arrays 107
mehrere Instanzobjekte 320, 330–334
mehrfache Vererbung 405
Klassen 380
Reihenfolge 405
mehrfache Verzweigung 159
Werkzeuge 238
Mehrfachziel-Zuweisungen 146
mehrzeilige Block-Strings 86
Mengen-Objekte 123
Metaprogramme 306, 308
Methoden
Aufrufe 346
Dictionaries 115
Klassen 344
Listen 109
Operatorüberladung 352
Strings 97
Microsoft Common Object Model (siehe COM)
min-Funktion 473
Mischen von Komponenten 27
Mixins 381
Modelle
Ausführung 22
dynamische Typisierung 74–79
Modifikation
Ausgabe 494
Dictionaries 114
Eingabe 494
Strings 94, 98
veränderliche Typen 103
Module 57, 267, 316
_ _name_ _ und _ _main_ _ 303
Attribute 42–44
ausführen 276
auswählen 274
Code 268
copy 481
Dateien 33–37
Datenkapselungskonvention 301–304
definieren 278–282
Entwurf 305–308
erneut laden 312
Erweiterungen 304
Fehlersuche 308–315
gemischte Verwendungsarten 303
Gültigkeitsbereich 216
importieren 41–42, 271–277
Internet 501–504
Klassen 336, 388
kompilieren 276
Namensräume 283–287
Pakete 292, 300
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Index |
617
Max.
Linie
Links
shutil 490
Standardbibliothek 271
suchen 272
Suchpfad ändern 304
Verwendungshinweise 44
Zahlwerkzeuge 73
(siehe auch erneutes Modul-Laden)
Module definieren 278–282
Muster
eingebaute String-Methoden 98
Entwurfs- 329
N
Namen
Änderungen an mehreren Dateien 282
Konventionen 148, 485, 487
Moduldateien 42–44
Qualifikation 285, 363
Typen 148
unqualifizierte Namen 362
Variablen-, Regeln 147
Verstümmelung 394
Verweis 145
Zuweisung 145
Namensänderungen an mehreren Dateien 282
Namensräume 212, 323, 362–368
Baumkonstruktion 347
class-Anweisung (Beispiel) 342
Dictionaries 364
LGB-Regel 214
Links 367
Module 268, 283–287
(siehe auch Gültigkeitsbereiche)
Negationsoperator 63
negative Abstände, Strings 90
None-Objekt 109, 133, 170, 197
not in-Operator 63
not-Operator 63, 164
numerische Genauigkeit 60
numerische Objekte
bitweise Operationen 69
lange Ganzzahlen 70
numerische Programmierung 11
NumPy, numerische Programmier-Erweiterung
11
Max.
Linie
618 | Index
O
Oberflächen
IDLE 45–49
Komodo 50
Programmierung 9
(siehe auch GUI)
Oberklassen 322, 334
abstrakte 350
Konstruktoren 346
oberste Ebene, Kopien auf 130
Objektänderung an Ort und Stelle 78
Objekte 57
Änderung an Ort und Stelle 78
einbetten 390
eingebaute 58
Fabriken 383
Fehlersuche 135–137
Funktionen 205
Gleichheitstests 131
Hierarchien 133–134
Klassifikation 126
kopieren 128–130, 479
Listen 104–106
Literale 59
mehrere Instanz- 330–334
Mengen 123
Namensräume 363
operations 106
Persistenz 10, 379
shared references 128–130
String-Methoden 97
veränderliche 260
Verbundtypen 126
Vergleiche 131–133
Wahrheitswerte 132
Zahlen 59–62, 65–73
objektorientierte Programmierung (siehe OOP)
Objektverweis
Erzeugung 145
Funktionen 205
oct-Funktion 473
offene Paar-Regel 163
öffnen von Windows-Icons 37–41
Oktalzahlen
Konstanten 61
Literale 60
Notation 72
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Rechts
OOP (Object-Oriented Programming) 12
Delegation 378
entwerfen mit 369
Fabriken 383
Klassen (Beispiel) 330
Klassenobjekte 330, 334
Überblick 321–329
Vererbung 372–378
Open Source-Software 12
open-Funktion 124
Operationen
Dateien 124
Dictionaries 112–115
Listen 106
Tupel 121
Operatoren
Ausdrücke 62–64
Klassen 337
kommutative 359
Strings 88–94
überladen 64, 320
Überladung 127
Klassen 337, 340, 351
Vorrang 62
Optionen, Dictionaries 114
ord-Funktion 471, 473
or-Operator 63, 164
os.environ-Dictionary 488
os.error-Ausnahme 488
os.listdir-Funktion 491
os.name-Attribut 488
os.path-Modul, -Funktionen 489
os.rename-Funktion 491
os-Modul 486–490, 522
Attributdefinition 488
Funktionen (oft benutzte) 486
String-Attribute 489
Ousterhout, John 526
P
Max.
Linie
Pakete
importieren 292–300
Module 300
parallele Traversierungen 181
Parameter, Funktionen 206
parsen
Argumente 222, 234
raise-Anweisungen 430
Text 101
partielle Anwendung von Funktionen 244
pass-Anweisung 169
PATH-Umgebungsvariable 37, 530
Performance 21
Perl-Sprache 15
Persistenz 379
Pfade
Module 272
Qualifikation 285
Suche 304
suchen 293
pickle-Modul 10, 520, 522
PIL (Python Imaging Library) 513
Polymorphie 208, 210, 230, 369
portable Datenbank-APIs 10
portables ANSI-C 13
positive Abstände, Strings 90
POSIX-Konventionen 487
print-Anweisungen 32, 152–155
in Dateien 35
Zahlen 67
Produktivität 5
profile-Modul 511
Programmierung 9
Architektur 268–271
ausführen 505–508
Ausnahmen 433–442
Code-Wiederverwendung 204
Datenbanken 10
Dokumentation 184–195
Endebehandlung 428
Fehlersuche 196
Funktionen 204–211
GUI 9
hello world 153
Interpreter 17
KI 11
Klassenbäume 324
Kommentare 65
Modell für dyn. Typisierung 74–79
Module 268, 278–282
Namen 212–218
numerische 11
OOP 321–329
String-Methoden 97
Strings 94–97
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Index |
Max.
Linie
619
Links
Struktur 57
Werkzeuge 243
Programmstruktur 269
Properties
Klassen 401
Listen 104–106
Syntaxregeln 160–164
Prototyp-Erstellung 11
pseudoprivate Klassenattribute 394–396
Psyco, Just-in-Time-Compiler 24
pth-Dateiverzeichnisse 273
PVM (Python Virtual Machine) 21
PyDev 50
PyDoc-Werkzeuge 189
HTML-Berichte 192
PyPy 25
Python ausführen
eingebetteter Code, Objekte 50–51
interaktive Kommandozeile 29–32
Interpreter 18
Moduldateien 33–37
Unix-artige Skripte 36
Python Imaging Library (PIL) 553
Python Virtual Machine (PVM) 21
Python.NET 23
PYTHONPATH-Variable 568
Verzeichnisse 273
PYTHONSTARTUP-Variable 568
PythonWin 50
Q
Qualifikation
_ _getattr_ _-Methode 357
Namen 285, 363
Qualität 4
Quellcode kompilieren 20
R
Max.
Linie
raise-Anweisung 429–431, 442
random-Modul 483
Rapid Prototyping 11
raw_input-Funktion 39, 448
re.compile( ) (Strings) 477
Rechte, ausführbare Skripte 36
Regeln
Gültigkeitsbereiche 212–218
LEGB 215
620 | Index
offene Paare 163
Syntax 160–164
reguläre Ausdrücke 474, 479
rekursiv importieren 311
re-Modul 474, 479
Repräsentationen, Strings 358
reservierte Wörter 147
Restoperator 63
return-Anweisungen 197, 205
reversed-Funktion 180
rohe Strings, Escapes unterdrücken 85
Rollen, Ausnahmen 416
RPython 25
S
Schleifen
Bereiche 178
Datei-Scanner 177
else 157, 169, 174
for 172–183
Formatierung 169–173
String-Iteration 89
verschachteln 246
while 167–169
Schlüsselwort-Argumente 226–234
Übergabe 241
Schnittstellen
Klassen 349
PyDoc 189
PythonWin 50
schreiben
auf sys.stdout 155
(siehe auch Code)
schreibweisenunabhängige Sortierung 483
Scripting 6, 9
Internet 9
PVM 21
Sprachen 13
umlenken 155
Unix-ähnliches 36
verpacken 451
Sequenzen 80
Ausführung 160
einbetten 82
Funktionen 242
Listen 106
überschneidende Elemente 209
unterdrücken 85
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Rechts
Max.
Linie
Shell-Werkzeuge 6
shelve-Modul 379
Shift-Operatoren 63
shutil-Modul 490
Signaturen, Aufrufe 370
Slicing 80, 90–91
Listen 107
Zuweisungen 108
Slots, Instanzen 400
Software-Qualität 4
Sortierung anpassen 483
sort-Methode 109, 482
spärliche (sparse) Datenstrukturen, Dictionaries
für 117
Speicher, automatische Verwaltung von 14
Speicherbereinigung 14
Verweise 79
speichern, Text 33
Spezialfall, Behandlung 416
Spiele 11
Sprachen
Vergleiche mit 15
zukünftige Eigenschaften einschalten 302
Sprachtabellen, Dictionaries 115
Stackless Python-System 25
Stacks 444
Standardargumente 227, 229, 260
Standard-Ausnahmebehandler 418
Standard-Bibliotheksmodule 271
Standard-Manualsatz 193
Standards, Dokumentations-Strings 188
Startoptionen 52
Startverzeichnis 272
statisch verschachtelte Gültigkeitsbereiche 219–
222
statische lokale Funktionsvariablen 260
statische Methoden, Klassen neuen Stils 400
Stein, Greg 521
Steuersprache 6
str-Funktion 472
string-Modul 474
Ersetzungsoperation 478
Funktionen 474
Konstanten 474
Problem mit regulären Ausdrücken 476
Strings
ändern, formatieren 94
Ausnahmen 433
Block- 86
Codes 96
definierte 80
Dokumentation 387–388
einfache Operationen 88–94
Formatierung 94–97
indizieren 90–91
Konstanten, Operationen 81
Listen 106
Literale 81–88
Methoden 97
modifizieren 94, 98
Slicing 90–91
Typkategorien 102
zurückgeben 358
Strings in doppelten Anführungszeichen 82
Strings in dreifachen Anführungszeichen 86
Strings in einfache Anführungszeichen 82
Strom-Umlenkung 34
struct-Modul 499
Formatierungscodes 500
suchen
Ausnahmen 448
Module 272
Pakete 293
-Pfad ändern 304
Vererbung 321
Swing Java GUI-Toolkit 513
syntaktische Verschachtelung 446
Syntax
Anweisungen 160–164
apply-Funktion 241
Ausführungssequenzen 160
Backslash 163
offene Paare 163
Syntaxregeln
Anweisungs-Begrenzungszeichen 162
Blöcke 160–161
Leerzeichen, Kommentare 160
Variablennamen 147
Verbundanweisungen 160
sys.modules-Dictionary 306
sys.path-Dictionary 304
sys.path-Listen 274
sys.stdout, Schreiben auf 155
Systemprogrammierung 9
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Index |
621
Links
T
Max.
Linie
Tabellen, Dictionaries 115
Tainting 26
tempfile-Modul 520
temporäre Dateien 493
Testen 508–511
testen
Ausnahmen 452
Code 31
Gleichheit 131–133
if-Anweisugnen 158
innerhalb des Prozesses ausführen 450
interaktiv 312
Wahrheitswerte 164–166
Tests hinzufügen 246
Tests innerhalb des Prozesses ausführen 450
Text 86
Ausnahmen 439
Dokumentations-Strings 188
Kommentare 65
parsen 101
speichern 33
String-Methoden 97
Strings modifizieren 94
umlenken 154
Texteditoren
Module 278–282
Startoptionen 52
time-Modul 509
Tk/Tkinter 9, 513, 526–532
GUI 513
Umgebungseinstellungen 569
Tracing 26
Traversierungen
parallele 181
Schleifen 180
try/except/else-Anweisung 421–428
try/finally-Anweisung 427
try-Anweisung 422
try/except/else-Anweisung 421
try/finally-Anweisung 427
Tupel
definierte 120–123
Eigenschaften 121
Funktionen 472
Inhalt sortieren 482
Zuweisung 145
622 | Index
Typen
Dateien 124–126
eingebaute 390–394
Einschränkungen 205
Fehlersuche 135–137
Gründe für eingebaute 57–59
Hierarchien 133–134
Iteratoren 254
Kategorien 102, 126
konvertieren 64, 472
Modell für dyn. Typisierung 74–79
Namen 148
Objekte 126
Sammlungstupel 120–123
veränderliche 103
Zahlen 59–62
U
Übergabe von Schlüsselwortargumenten 241
überladen von Operatoren 64, 127, 320
Klassen 340, 351
Übersetzung, Psyco, Just-in-Time-Compiler 24
umgebende
Ausdrücke 63
Funktionen 214
Umgebung 567
umlenken
Ausgabeströme 154
Skripte 155
ungebundene Klassenmethoden 385
Unicode-Strings 86
Unix-ähnliche System-Skripte 36
unqualifizierte Namen 362
Unterausdrücke 63
unterdrücken von Escape-Sequenzen 85
Unterklassen 322, 334, 391
unveränderliche Sequenzen 80
unveränderliche Typen ändern 137
urllib-Modul 502
urlparse-Modul 503
URLs, urllib-Modul 502
V
van Rossum, Guido 541
Variablen 43
einfache 285
lokale 211
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Rechts
Max.
Linie
Namensregeln 147
Zahlen 65
Zuweisungen 74
Variationen, Ausführungsmodelle 22
veränderliche Argumente, Änderungen an 223
veränderliche Objekte 260
veränderliche Typen 103
Veränderlichkeit 80, 103, 137
Verarbeitung
Dateien 125, 495
Zahlobjekte 61
Zeilen 499
Verbergen von Objekten 26
Verbreitung von Ausnahmen 420, 431
Verbundanweisungen 32, 160
Verbundobjekttypen 126
Vererbung 320, 369
Anpassung 320
diamantförmig 397
Klassen 334, 383
Konstruktion von Namensraumbäumen 347
mehrfache 405
OOP 372–378
Spezialisierungsmethoden 348–350
Suche 321
Vergleiche 470–474
importieren/Gültigkeitsbereiche 286
Klassen/Module 388
Objekte 131–133
Operatoren 63
Sprachen 15
Zahlen 472
Verkettung 80
+ (Addition/Verkettung) 338
Strings 88–94
Verpacken von Anweisungen 451
verschachteln
Ausnahmen 444–448, 451–455
Blöcke 160
Funktionen 219–222
Gültigkeitsbereiche 154, 206, 366
Kontrollfluss 445
Lambdas 238
Listen 107
Namensräume 213, 287
Schleifen 246
syntaktisch 446
Verwaltung von Speicher, automatische 14
Verweise
Argumente 223
gemeinsame 128–130
Objektänderung an Ort und Stelle 78
Speicherbereinigung 79
Vergleich mit Kopien 145
Zuweisungen 135
Verwendungshinweise 44, 116
Verzeichnisse kopieren 490
verzögerte Auswertung 26
Vorrang
Ausdrücke 63
Regeln (Operatoren) 62
Vorwärtsverweise 310
W
Wahrheitswerte
Objekte 132
testen 164–166
Webseiten, cgi-Modul 501
Website-Ressourcen XXII
Werkzeuge
Ausdrücke 62–64
Dokumentation 185
eingebaute Funktionen 73
mehrfache Verzweigung 238
Programmierung 243
PyDoc 192
Shell 6
Zahlen 61
Werte
Funktionen 231
Standardargumente 260
Wahrheitswerte 164–166
Wahrheitswerte für Objekte 132
while-Schleife 167–169
Wide-Character-Strings 86
Wiederholung, eine Ebene tief 136
win32com 521
Dispatch-Funktion 522
formletter.py-Programm 521
Windows
automatische Erweiterungen 35
Icons 37–41
(siehe auch Oberflächen)
Wing IDE 50
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Max.
Linie
Index |
623
Links
X
XML (Extensible Markup Language) 9, 11, 14
Z
Zahlen 59–62, 67, 470–474
Ausdrücke 62–64
Dezimalzahlen 74
einfache Operationen 65–73
eingebaute Typen 57–59
komplexe Zahlen 71
print-Anweisungen 67
Zuweisungen 74
Zählschleifen 167–169, 178
Zeichen
große Mengen kodieren 86
Listen 181
Zeilen, Verarbeitung 499
zip-Funktion 181, 183
Zope 559
Zusammenhalt 255
zusätzliche Daten an Instanzen schicken 440
Zuweisungen 74
C 173
Funktionen durch 205
Listen 108
Namen, klassifizierende 363
Objektänderung an Ort und Stelle 78
Verweise 135
Zuweisungsanweisungen 144, 149, 151, 281
Formen 145
implizite 145
Objektverweise 145
Regeln für Variablennamen 147
zyklische Datenstrukturen ausgeben 136
Max.
Linie
Max.
Linie
624 | Index
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.