Python Ge-Packt - mitp

I
E
1
2
Inhaltsverzeichnis
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
E.1
E.2
E.3
E.4
Was ist Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Einige besondere Merkmale von Python. . . . . . . . . . . .
Python 2 und 3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Hinweise zum Lesen dieses Buches . . . . . . . . . . . . . . .
13
13
14
15
Basiskonzepte von Python . . . . . . . . . . . . . . . . . . . . . .
19
1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9
Python im interaktiven Modus . . . . . . . . . . . . . . . . . . . .
Ausführung von Python-Skripten. . . . . . . . . . . . . . . . . .
Die Zeilenstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Deklaration der Codierung . . . . . . . . . . . . . . . . . . . . . . .
Bezeichner (identifiers) . . . . . . . . . . . . . . . . . . . . . . . . .
Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Die Standard-Typ-Hierarchie . . . . . . . . . . . . . . . . . . . . .
Literale für einfache Datentypen . . . . . . . . . . . . . . . . . .
Namensräume – lokale und globale Namen . . . . . . . . .
19
20
23
25
26
28
32
33
40
Sequenzen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
45
2.1
2.2
2.3
2.4
2.5
45
48
54
56
71
Gemeinsame Operationen für Sequenzen . . . . . . . . . .
Zeichenketten (Strings). . . . . . . . . . . . . . . . . . . . . . . . . .
Tupel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Performance-Tipps . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Inhaltsverzeichnis
3
Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
75
4
Mengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
87
4.1
4.2
4.3
87
88
Der Typ set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Typ frozenset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gemeinsame Operationen für set- und
frozenset-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mengen verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
89
93
Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
95
5.1
5.2
5.3
5.4
5.5
5.6
5.7
96
97
101
102
104
105
106
4.4
5
Unäre arithmetische Operatoren + - ~. . . . . . . . . . . . . .
Binäre arithmetische Operatoren + - * / % ** . . . . . . . .
Bit-Operatoren << >> & ^ | . . . . . . . . . . . . . . . . . . . . . .
Vergleiche < <= > >= != == . . . . . . . . . . . . . . . . . . . . .
Zugehörigkeit (in, not in) . . . . . . . . . . . . . . . . . . . . . . . .
Identitätsvergleich (is, is not). . . . . . . . . . . . . . . . . . . . .
Logische Operatoren (not, and, or) . . . . . . . . . . . . . . . .
6
Einfache Anweisungen (Statements) . . . . . . . . . . . . . . 109
7
Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
7.1
7.2
7.3
7.4
7.5
7.6
8
Verzweigungen – die if-Anweisung . . . . . . . . . . . . . . . . 129
Bedingte Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Verzweigungen mit logischen Operatoren . . . . . . . . . . 131
Iterationen – die for-Anweisung. . . . . . . . . . . . . . . . . . . 133
Schleifen mit Abbruchbedingung – while . . . . . . . . . . . 137
Abfangen von Laufzeitfehlern – try . . . . . . . . . . . . . . . . 139
Definition von Funktionen . . . . . . . . . . . . . . . . . . . . . . . 145
8.1
8.2
8.3
Aufruf und Ausführung einer Funktion . . . . . . . . . . . . . 146
Funktionsnamen als Parameter . . . . . . . . . . . . . . . . . . . 149
Voreingestellte Parameterwerte . . . . . . . . . . . . . . . . . . 149
6
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Inhaltsverzeichnis
8.4
8.5
8.6
8.7
8.8
8.9
8.10
8.11
8.12
Schlüsselwort-Argumente . . . . . . . . . . . . . . . . . . . . . . .
Funktionen mit beliebiger Anzahl von Parametern . . .
Prozeduren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rekursive Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . .
Funktionen testen mit dem Profiler . . . . . . . . . . . . . . . .
Lokale Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Generatorfunktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lambda-Formen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Decorators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
150
152
153
153
154
155
156
160
161
9
Standardfunktionen (built in functions) . . . . . . . . . . . 165
10
Fehler und Ausnahmen . . . . . . . . . . . . . . . . . . . . . . . . . 209
10.1
10.2
10.3
10.4
Syntaxfehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ausnahmen (Exceptions) . . . . . . . . . . . . . . . . . . . . . . . .
Erstellen einer eigenen Exception-Klasse . . . . . . . . . . .
Testen von Vor- und Nachbedingungen
mit assert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.5 Selbstdokumentation im Debugging-Modus . . . . . . . .
10.6 Das Modul logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
219
220
222
Ein- und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
11.1
11.2
11.3
11.4
11.5
11.6
11.7
12
209
210
214
Interaktive Eingabe über die Tastatur . . . . . . . . . . . . . .
Kommandozeilen-Argumente lesen. . . . . . . . . . . . . . . .
Formatierte Bildschirmausgabe . . . . . . . . . . . . . . . . . . .
Lesbare Darstellung komplexer Objekte –
das Modul pprint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Objekte speichern – pickle . . . . . . . . . . . . . . . . . . . . . . .
Zugriff auf beliebige Ressourcen über
deren URL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
233
234
238
241
243
253
259
Schnittstelle zum Laufzeitsystem – sys. . . . . . . . . . . . 261
7
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Inhaltsverzeichnis
13
Schnittstelle zum Betriebssystem – os
und os.path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
13.1 Das Modul os . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
13.2 Das Modul os.path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
14
Datum und Zeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
14.1 Das Modul time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
14.2 Das Modul datetime . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
15
Objektorientierte Programmierung mit Python . . . . . 303
15.1
15.2
15.3
15.4
15.5
16
304
308
311
321
324
Verarbeitung von Zeichenketten . . . . . . . . . . . . . . . . . 331
16.1
16.2
16.3
16.4
16.5
16.6
17
Definition von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . .
Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vererbung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Definition von Klassenbibliotheken . . . . . . . . . . . . . . . .
Standardmethoden für String-Objekte . . . . . . . . . . . . .
Das Modul string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Formatierung mit dem %-Operator . . . . . . . . . . . . . . . .
Formatstrings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Reguläre Ausdrücke – das Modul re . . . . . . . . . . . . . . .
Performance-Tipps zur Zeichenkettenbearbeitung . . .
331
341
344
346
351
363
Mathematische Funktionen. . . . . . . . . . . . . . . . . . . . . . 365
17.1
17.2
17.3
17.4
17.5
17.6
array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
cmath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
decimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
statistics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
365
368
369
378
380
388
8
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Inhaltsverzeichnis
18
CGI-Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
18.1
18.2
18.3
18.4
18.5
18.6
19
393
396
400
404
406
407
Internet-Programmierung . . . . . . . . . . . . . . . . . . . . . . . 411
19.1
19.2
19.3
19.4
19.5
19.6
20
CGI-Skripte erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Kommunikation über HTML-Formulare . . . . . . . . . . . . .
Die Klasse cgi.FieldStorage . . . . . . . . . . . . . . . . . . . . . .
Installation von CGI-Skripten . . . . . . . . . . . . . . . . . . . . .
Das Modul cgitb – CGI-Skripte debuggen . . . . . . . . . . .
Cookies. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Modul ftplib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erstellen eines CGI-Webservers . . . . . . . . . . . . . . . . . . .
Das Modul imaplib . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Modul poplib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Modul smtplib . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Modul telnetlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
412
415
416
418
421
424
Datenbanken. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
20.1 Eine MySQL-Datenbank erstellen . . . . . . . . . . . . . . . . . 428
20.2 Das Modul MySQLdb – Zugriff auf
MySQL-Datenbanken . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
20.3 Das Modul sqlite3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
21
Das Modul hashlib – Digitale Signaturen . . . . . . . . . . 445
21.1 Hashing-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
21.2 Anwendung in der Sicherheitstechnik –
Passwortgeschützte Online-Plattform . . . . . . . . . . . . . . 448
22
Grafische Benutzungsoberflächen . . . . . . . . . . . . . . . . 461
22.1 Widgets des Moduls tkinter . . . . . . . . . . . . . . . . . . . . . . 462
22.2 Die Benutzungsoberfläche als Aggregat
von Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
22.3 Attribute der Widgets (Optionen) . . . . . . . . . . . . . . . . . 466
9
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Inhaltsverzeichnis
22.4 Standard-Methoden der Widgets. . . . . . . . . . . . . . . . . .
22.5 Die Klasse Button . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.6 Die Klasse Canvas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.7 Checkbutton. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.8 Entry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.9 Frame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.10 Label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.11 Listbox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.12 Menu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.13 Menubutton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.14 Die Klasse PhotoImage . . . . . . . . . . . . . . . . . . . . . . . . . .
22.15 Radiobutton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.16 Scale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.17 Scrollbar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.18 Die Klasse Text. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.19 Tk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.20 Layout-Manager. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.21 Kontrollvariablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.22 Dialogboxen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22.23 Event-Verarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
Bild und Ton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555
23.1
23.2
23.3
23.4
24
476
480
481
494
498
499
500
500
503
512
515
516
518
521
523
531
532
543
544
546
Der Python Package Index . . . . . . . . . . . . . . . . . . . . . . .
Die Python Imaging Library (PIL) . . . . . . . . . . . . . . . . . .
Klänge mit Winsound . . . . . . . . . . . . . . . . . . . . . . . . . . .
PlaySound() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
555
556
573
575
Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
24.1 Funktionen in einem Thread ausführen:
start_new_thread() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578
24.2 Thread-Objekte erzeugen – die Klasse Thread . . . . . . . 579
24.3 Die Klasse Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
10
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Inhaltsverzeichnis
25
XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
25.1 Das Modul xml.dom.minidom . . . . . . . . . . . . . . . . . . . .
25.2 Verarbeitung eines XML-Objektes –
Einführendes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . .
25.3 Parsing – ein DOM-Objekt erstellen. . . . . . . . . . . . . . . .
25.4 Knoten eines DOM-Objektes –
die Basisklasse Node . . . . . . . . . . . . . . . . . . . . . . . . . . .
25.5 Die Klasse Document . . . . . . . . . . . . . . . . . . . . . . . . . . .
25.6 Die Klasse Element . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25.7 Die Klasse Text. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
A
586
587
590
591
600
601
605
Ressourcen im Internet . . . . . . . . . . . . . . . . . . . . . . . . . 607
A.1
A.2
A.3
Usenet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
Mailinglisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
WWW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
B
Entwicklungsumgebungen . . . . . . . . . . . . . . . . . . . . . . 609
C
Python-Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
D
Von Python 2 zu Python 3 . . . . . . . . . . . . . . . . . . . . . . . 615
D.1
D.2
E
Unterschiede zwischen Python 2 und Python 3 . . . . . .
Portierung nach Python 3 . . . . . . . . . . . . . . . . . . . . . . . .
615
618
Glossar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
11
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1
1.1
Basiskonzepte von
Python
Python im interaktiven Modus
Der Python-Interpreter kann in einem interaktiven Modus verwendet
werden, in dem Sie einzelne Zeilen Programmtext eingeben und die Wirkung sofort beobachten können. Im interaktiven Modus können Sie mit
Python experimentieren, etwa um sich in neue Programmiertechniken
einzuarbeiten oder logische Fehler in einem Programm, das Sie gerade
bearbeiten, aufzuspüren.
Der interaktive Python-Interpreter – die Python-Shell – kann auf verschiedene Weise gestartet werden:
1. In einem Konsolenfenster (z.B. Eingabeaufforderung bei WindowsSystemen) geben Sie das Kommando python ein. Damit das Betriebssystem den Python-Interpreter findet, muss der Systempfad richtig
gesetzt sein. Unter Windows 7 klicken Sie auf den START-Button links
unten. Klicken Sie mit der rechten Maustaste auf COMPUTER und wählen Sie im Kontextmenü den Punkt EIGENSCHAFTEN. Wählen Sie den
Link ERWEITERTE SYSTEMEINSTELLUNGEN. Es öffnet sich ein neues Fenster
mit dem Titel SYSTEMEIGENSCHAFTEN. Klicken Sie auf der Registerkarte
ERWEITERT unten auf die Schaltfläche UMGEBUNGSVARIABLEN. Wählen
Sie die Systemvariable PATH und klicken Sie auf BEARBEITEN. In dem
Feld WERT DER VARIABLEN bringen Sie den Cursor an das Ende der Zeichenfolge und hängen den folgenden Text an:
;C:\Python34
2. Bei Windows-Rechnern klicken Sie im Menü START|ALLE PROGRAMME|
PYTHON3.4 das Programm-Icon PYTHON (COMMAND LINE) an.
3. Sie öffnen die Entwicklungsumgebung IDLE, die zum Standardpaket
gehört. Sie enthält neben einem Editorfenster ein eigenes Shell19
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
Fenster, in dem man auf der Kommandozeile Python-Statements
eingeben kann.
Die Python-Shell meldet sich immer mit einer kurzen Information über
die Version und einigen weiteren Hinweisen. Dann folgt der charakteristische Promptstring aus drei spitzen Klammern >>> als Eingabeaufforderung. Hinter dem Prompt können Sie eine Anweisung eingeben und
durch (¢) beenden. In den nächsten Zeilen kommt entweder eine Fehlermeldung, ein Funktionsergebnis oder (z.B. bei Zuweisungen) keine Systemantwort. Beispiel:
>>> 2+2
4
Wichtige Tastenkombinationen
Es lohnt sich, einige wenige Tastenkombinationen zur effizienten Bedienung der Python-Shell auswendig zu lernen:
Vorige Anweisung. Mit der Tastenkombination (Alt)+(p) können Sie
den vorigen Befehl (previous command) noch einmal in die Kommandozeile schreiben. Drücken Sie mehrmals diese Tastenkombination, werden
die noch weiter zurückliegenden Anweisungen geholt.
Nächste Anweisung. Wenn Sie mehrmals auf (Alt)+(p) gedrückt haben,
können Sie mit (Alt)+(N) wieder zum nächstneueren Kommando springen (next command).
Keyboard Interrupt. Mit der Tastenkombination (Strg)+(C) können Sie
den Abbruch eines laufenden Programms erzwingen. Das ist z.B. für das
Testen von Programmen mit while-Anweisungen wichtig, weil eventuell
eine Endlosschleife vorliegt und das Programm von alleine nicht anhält.
1.2
Ausführung von Python-Skripten
Python-Programme – meist nennt man sie Skripte – sind Textdateien, die
unter einem Namen mit der Extension .py oder unter Windows auch .pyw
abgespeichert werden, z.B. hello.py. Ein Python-Skript wird von einem
20
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.2 Ausführung von Python-Skripten
Python-Interpreter ausgeführt (interpretiert), der letztlich den Programmtext in maschinenbezogene Befehle überführt. Das heißt: Das
Skript ist plattformunabhängig, aber für jedes Betriebssystem gibt es
einen eigenen Interpreter. Um ein Python-Skript ausführen zu können,
muss dem Betriebssystem auf irgendeine Weise mitgeteilt werden, welches Programm es zur Interpretation einsetzen soll. Voraussetzung für die
Ausführung eines Skripts ist, dass Python installiert und Systempfade,
Umgebungsvariablen usw. korrekt gesetzt sind.
Grundsätzlich kann ein Python-Skript von einer Entwicklungsumgebung
(z.B. IDLE) aus gestartet werden. Darüber hinaus gibt es folgende plattformabhängigen Möglichkeiten.
Windows
Unter Windows können Sie ein Python-Skript auf zweierlei Weise ausführen:
1. Öffnen Sie ein Konsolenfenster (Eingabeaufforderung) und geben
Sie das Kommando python gefolgt vom Pfad des Python-Skripts ein.
Beispiel:
python meinSkript.py
2. Klicken Sie im Explorer-Fenster auf das Icon des Python-Skripts (stilisierte Schlange). Das Betriebssystem öffnet ein Konsolenfenster, in
dem Ein- und Ausgaben erfolgen. Nach Beendigung des Programms
wird das Fenster sofort wieder geschlossen. Das hat den Nachteil,
dass die letzte Ausgabe des Programms nicht mehr gelesen werden
kann. (Abhilfe bietet hier z.B. eine input-Anweisung am Ende des
Programms. Sie erzwingt, dass das DOS-Fenster geöffnet bleibt, bis
die (¢)-Taste gedrückt ist.)
Bei Programmen mit grafischer Benutzungsoberfläche, die in einem
eigenen Anwendungsfenster laufen, wird es als störend empfunden,
wenn sich zuerst ein Konsolenfenster öffnet. Solche Skripte sollte man
unter einem Namen mit der Extension .pyw abspeichern, z.B. editor.pyw.
21
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
Dann erscheint nach dem Anklicken des Programmicons kein DOS-Fenster, sondern sofort die Applikation.
Unix
Unter Unix kann man (wie bei MS Windows) in einem Shell-Fenster (Konsole) den Python-Interpreter durch ein Kommando der folgenden Form
starten:
python meinSkript.py
Außerdem gibt es bei Unix den Mechanismus der so genannten magic
line. In der ersten Zeile des Skripts kann spezifiziert werden, mit welchem
Interpreter das Skript ausgeführt werden soll. Die magic line beginnt mit
der Zeichenfolge #!, dahinter folgt entweder direkt der Pfad zum
Python-Interpreter oder der Pfad zu einem Dictionary (env), in dem die
Systemadministration den Pfad zum Python-Interpreter eingetragen hat.
Wenn das Unix-System standardmäßig eingerichtet ist, müsste eine der
beiden folgenden magic lines funktionieren:
#!/usr/bin/python
#!/usr/bin/env python
Das Python-Skript mit einer magic line ist direkt ausführbar. Zum Start
reicht z.B. die Eingabe des Dateinamens in der Konsole. Voraussetzung
ist allerdings, dass die Zugriffsrechte entsprechend gesetzt sind, das
heißt, das executable-Bit (x) muss mit Hilfe des Unix-Kommandos chmod
auf 1 gesetzt sein.
CGI-Skripte, die von jedermann über das Internet gestartet werden können, müssen eine magic line enthalten. Die Rechtevergabe erfolgt üblicherweise nach folgendem Muster:
chmod 711 meinSkript.py
Damit hat der Besitzer alle Rechte, die anderen dürfen die Datei nur ausführen, nicht aber lesen oder ändern.
22
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.3 Die Zeilenstruktur
1.3
Die Zeilenstruktur
Ein Python-Skript ist eine Folge von Anweisungen. Im Unterschied zu
anderen Programmiersprachen muss bei Python eine Anweisung nicht
durch ein besonderes Zeichen (wie das Semikolon bei Java) abgeschlossen
werden. Ebenso gibt es keine Zeichen für Beginn und Ende eines Anweisungsblocks (wie z.B. geschweifte Klammern in Java oder begin und end
in Pascal).
Das Ende einer Anweisung wird durch das Zeilenende markiert. Somit
darf sich eine Anweisung nicht über mehrere Zeilen erstrecken.
Erlaubt ist:
summe = 1 + 2
Nicht erlaubt ist:
summe = 1
+ 2
Python unterscheidet aber zwischen »physischen« und »logischen« Zeilen.
Eine physische Zeile endet mit einem (unsichtbaren) betriebssystemabhängigen Steuerungssymbol für den Zeilenwechsel. Bei Unix ist das das
ASCII-Zeichen LF (linefeed), bei DOS/Windows-Systemen die ASCII-Zeichenfolge CR LF (carriage return und linefeed) und bei Mac OS das ASCIIZeichen CR.
Explizites Verbinden von Zeilen
Mit Hilfe eines Backslashs \ kann man in einem Python-Skript mehrere
physische Zeilen zu einer logischen Zeile verbinden. Damit ist folgender
Programmtext eine gültige Anweisung:
summe = 1 \
+ 2
Hinter dem Backslash darf aber in derselben Zeile kein Kommentarzeichen # stehen, denn ein Kommentarzeichen beendet eine logische Zeile.
Nicht erlaubt ist also:
23
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
summe = 1 \ # Summenberechnung
+ 2
Implizites Verbinden von Zeilen
Geklammerte Ausdrücke (mit normalen, eckigen oder geschweiften
Klammern) sind häufig sehr lang. Sie dürfen bei Python auf mehrere physische Zeilen verteilt werden und werden implizit zu einer einzigen logischen Zeile verbunden. Beispiele:
wochentage = ["Sonntag","Montag","Dienstag",
"Mittwoch", "Donnerstag", "Freitag", "Samstag"]
def volumen(h,
# Höhe,
b,
# Breite und
t): # Tiefe eines Quaders
return h*b*t
Das zweite Beispiel zeigt auch Folgendes: Im Unterschied zu Zeilen, die
mit einem Backslash \ explizit verbunden sind, dürfen implizit verbundene Zeilen Kommentare enthalten. Das ist auch sehr sinnvoll. Denn die
Parameter einer Funktion möchte man häufig einzeln kommentieren.
Einrückungen – Anweisungsblöcke
Ein Anweisungsblock (in der Python-Dokumentation suite genannt) ist
eine Folge von zusammengehörigen Anweisungen, z.B. das Innere einer
Schleife, der Körper einer Funktionsdefinition oder ein Zweig einer ifelse-Anweisung. Ein Block kann weitere Blöcke als Unterblöcke enthalten. Beginn und Ende eines Blocks werden in einem Python-Skript nicht
durch lesbare Symbole (geschweifte Klammern { } bei C oder Java), sondern durch eine Einrückung (indent) um eine bestimmte Anzahl von Stellen festgelegt. Beispiel:
a = 0
for i in range(5):
a = a + i
# Beginn eines Blocks
print(a)
# Ende des Blocks
print("Ende der Rechnung")
Die Anzahl der Leerzeichen vor dem ersten Nichtleerzeichen (Einrückungsgrad) ist beliebig. Wichtig ist allein, dass alle zusammengehörigen
24
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.4 Deklaration der Codierung
Anweisungen eines Blocks um exakt die gleiche Anzahl von Stellen eingerückt sind. Es ist gleichgültig, ob Sie beim Editieren Tabulatorzeichen
(Tab) oder Leerzeichen verwenden. Empfohlen wird, Tabs und Leerzeichen
nicht zu mischen. Der Python-Interpreter wandelt intern Tabulatorzeichen in die entsprechende Anzahl von Leerzeichen um. Am Ende eines
Skripts werden alle begonnenen Blöcke vom Interpreter wieder beendet.
Das folgende Beispielskript zeigt einige typische Einrückungsfehler:
def primzahl(n):
teiler_gefunden = 0
for i in range(2,n):
if n%i == 0:
print("keine Primzahl")
teiler_gefunden = 1
break
if not teiler_gefunden:
print("Primzahl")
#1
#2
#3
#4
1. Fehler: Die erste Zeile darf nicht eingerückt sein.
2. Fehler: Nach dem Doppelpunkt beginnt ein neuer Block, es muss eingerückt werden.
3. Fehler: Unerwartete Einrückung. Die Zeile muss genauso weit eingerückt sein wie die Zeile davor.
4. Fehler: Inkonsistente Einrückung. Die Anweisung gehört zum gleichen Block wie die for-Anweisung und muss ebenso weit eingerückt
sein.
1.4
Deklaration der Codierung
Python-Skripte sollten in der ersten oder zweiten Zeile eine Zeile der
Form
# -*- coding: <encoding-name> -*-
enthalten, die die Codierung des Textdokumentes angibt. Wenn die
Deklaration der Codierung fehlt, wird utf-8 angenommen. Beispiele:
25
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
# -*- coding: latin-1 -*import sys, os
…
#!/usr/bin/python
# -*- coding: iso-8859-15 -*import sys, os
...
Siehe auch: Kapitel 16 (String-Methoden decode() und encode())
1.5
Bezeichner (identifiers)
Bezeichner (identifiers) sind Zeichenketten, die für die Namen von Funktionen, Klassen, Variablen usw. verwendet werden dürfen. Ein Bezeichner
(häufig spricht man auch von Namen) kann beliebig lang sein, muss mit
einem Buchstaben oder einem Unterstrich beginnen und ist ansonsten
aus Buchstaben, Ziffern und Unterstrichen zusammengesetzt. Es wird
zwischen Groß- und Kleinschreibung unterschieden. Im Unterschied zu
den Vorgängerversionen lässt Python 3 auch Unicode-Zeichen zu, die
Buchstaben repräsentieren, aber nicht zum ASCII-Zeichensatz gehören.
Erlaubt sind also insbesondere auch deutsche Umlaute und ß. Gültige
Bezeichner sind z.B. x, x1, straßenname, __privat, Class_1.
Empfohlen wird allerdings, sich bei Bezeichnern an die Syntax von
Python 2 zu halten und nur ASCII-Zeichen zu verwenden.
Python 2.x
Bei Python 2.x sind nur ASCII-Zeichen für Bezeichner zugelassen. Die
Grammatikregeln lauten:
identifier ::=
(letter|"_") (letter | digit | "_")*
letter ::= lowercase | uppercase
lowercase ::="a"..."z"
uppercase ::= "A"..."Z"
digit ::= "0"..."9"
26
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.5 Bezeichner (identifiers)
Schlüsselwörter (keywords)
Die folgenden Bezeichner sind reservierte Wörter oder Schlüsselwörter
von Python. Sie dürfen nicht als Bezeichner z.B. für Variablennamen verwendet werden.
and
continue
except
global
lambda
pass
while
as
def
False
if
None
raise
with
assert
del
finally
import
nonlocal
return
yield
break
elif
for
in
not
True
class
else
from
is
or
try
Im Modul keyword gibt es eine Funktion, mit der getestet werden kann,
ob ein String ein Schlüsselwort ist.
>>> import keyword
>>> keyword.iskeyword("with")
True
Verwendung von Unterstrichen
Unterstriche am Anfang und am Ende eines Bezeichners haben eine
besondere Bedeutung.
Doppelte Unterstriche am Anfang und am Ende eines Bezeichners (z.B.
__init__) kennzeichnen Objekte, die mit einem bestimmten »magischen« Verhalten verbunden sind. In Klassen z.B. gibt es immer eine Methode __init__(), die für die Initialisierung einer Instanz der Klasse zuständig ist (Konstruktor). Diese Methode wird aber nicht mit __init__()
aufgerufen, sondern über den Namen der Klasse. Bezeichner mit doppelten Unterstrichen vorne und hinten verwendet man auch, um Operatoren zu überladen (siehe Kapitel 15.3).
Bezeichner, die mit zwei Unterstrichen beginnen, aber nicht mit Unterstrichen enden, werden für private Methoden und Attribute in Klassendefinitionen verwendet.
27
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
Ein einzelner Unterstrich am Anfang (z.B. _irgendwas) bewirkt, dass das
bezeichnete Objekt durch die Anweisung from modul import * nicht in den
Namensraum importiert wird. Bezeichner, die mit einem Unterstrich
beginnen, sind also für interne Attribute und Methoden gedacht, die nur
innerhalb eines Moduls verwendet werden.
Einen einzelnen Unterstrich am Ende verwendet man üblicherweise, um
Namenskonflikte mit existierenden Schlüsselwörtern zu vermeiden.
Siehe auch: Kapitel 15.3
1.6
Objekte
Identität von Objekten
Python ist in einem sehr umfassenden Sinne eine objektorientierte Programmiersprache. Daten, Funktionen, Programmcode, Ausnahmen, Prozessframes und andere Sprachelemente werden durch Objekte repräsentiert. Jedes Objekt besitzt eine Identität, einen Wert und einen Typ.
Die Identität eines Objektes wird durch eine (einmalige) ganze Zahl repräsentiert, die mit der Standardfunktion id() abgefragt werden kann. Zwei
Objekte mit gleichem Wert können unterschiedliche Identität besitzen.
Mit dem Operator is kann ermittelt werden, ob zwei Objekte (angesprochen über Namen) dieselbe Identität besitzen.
Änderbare und unveränderbare Objekte
Bei manchen Objekten kann sich der Wert während ihrer Lebensdauer
ändern. Man bezeichnet sie als änderbar (mutable). Zu den änderbaren
Objekten gehören Listen. Objekte, die bei ihrer Erschaffung einen festen
Wert erhalten, den sie bis zu ihrer Zerstörung behalten, bezeichnet man
als unveränderbar (immutable). Zu den unveränderbaren Objekten gehören z.B. alle einfachen numerischen Datentypen (ganze Zahlen, Gleitkommazahlen etc.), Zeichenketten und Tupel.
28
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.6 Objekte
Betrachten wir folgende Anweisungsfolge:
>>> a = 'ab'
>>> a = 'cd'
Hier wird nicht etwa der Wert eines Objektes geändert. In der ersten Zeile
wird ein unveränderbares Objekt vom Typ String mit dem Wert 'ab'
geschaffen und dem Namen a zugeordnet. In der zweiten Zeile wird ein
neues String-Objekt mit dem Wert 'cd' erzeugt und (anstelle des ersten
Objektes mit dem Wert 'ab') dem Namen a zugeordnet.
Das »alte« Objekt 'ab' wird übrigens durch die zweite Zuweisung nicht
zerstört, sondern es ist jetzt einfach nicht mehr über den Namen a
erreichbar. Erst die »garbage collection« (Müllabfuhr) des Laufzeitsystems
sorgt dafür, dass nicht mehr erreichbare Objekte beseitigt werden.
Eine logische Schwierigkeit tritt bei Container-Objekten auf. ContainerObjekte (z.B. Listen, Tupel) enthalten Referenzen auf andere Objekte. So
enthält das Tupel ([1, 2], [3, 4]) Referenzen auf die Objekte [1, 2] und
[3, 4]. Nun ist zwar ein Tupel unveränderbar, die Elemente des Tupels sind
jedoch veränderbare Listen.
Typen und Klassen
Jedes Objekt gehört zu einem bestimmten Typ, der durch eine Klasse definiert ist. Der Typ kann mit der Standardfunktion type() ermittelt werden.
Beispiel:
>>> type (123)
<class 'int'>
>>> type('123')
<class 'str'>
Aus dem Typ ergeben sich bestimmte Eigenschaften eines Objektes. So
können bestimmte Operatoren nur auf Objekte mit numerischem Typ
(z.B. ganze Zahlen oder Gleitkommazahlen) angewendet werden. Der
Ausdruck a*b + c/d macht nur Sinn, wenn a, b, c, d die Namen von numerischen Objekten sind.
29
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
Die Begriffe Typ und Klasse haben fast die gleiche Bedeutung. Ein Typ
ist die Außenansicht einer Klasse. Seit Python 2.5 ist die Unterscheidung
zwischen selbst definierten Klassen und vorgegebenen Standardtypen
(built-in types) weitgehend aufgehoben.
Mit der Standardfunktion isinstance() kann man testen, ob ein Objekt
(erstes Argument) zu einer bestimmten Klasse (zweites Argument)
gehört:
>>> isinstance (1, int)
True
Wahrheitswert
Daten-Objekte besitzen neben ihrem Wert auch einen Wahrheitswert
(»wahr« oder »falsch«). Der Wahrheitswert ist eigentlich keine besondere
Eigenschaft eines Objektes, sondern er ergibt sich unmittelbar aus dem
Wert. Numerische Objekte mit dem Wert 0 und leere Container-Objekte
haben den Wahrheitswert »falsch« und alle anderen Objekte dieser Kategorien tragen den Wahrheitswert »wahr«. Diese Konvention ermöglicht
eine sehr kompakte Formulierung von Bedingungen (vgl. Kapitel 7). So
ist z.B. folgende Anweisung gültiger Python-Programmtext:
while x:
x = x-1
In der Bedingung hinter dem Schlüsselwort while wird der Wahrheitswert
von x abgefragt, während im Schleifeninneren der numerische Wert verwendet wird.
Namen
Objekte sind über Namen erreichbar. Mit der Zuweisung a = 1 wird dem
Objekt 1 der Name a zugeordnet. Dasselbe Objekt kann mehrere Namen
besitzen.
30
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.6 Objekte
a
1
b
Objekt
Namen
Abbildung 1.1: Variablen als Namen für Objekte
Namen für Daten werden häufig als Variablen bezeichnet. Eine Variable
stellt man sich in der Informatik oft als Behälter vor, der als Inhalt ein
Datenobjekt, etwa eine Zahl, besitzt (siehe Abbildung 1.2).
Wert
1
Variable
Variablenname
a
1
b
Abbildung 1.2: Variablen als Behälter für Werte
Im Falle einfacher unveränderbarer Datenobjekte (wie z.B. Zahlen) ist
diese Metapher unproblematisch. Schwierigkeiten bekommt man mit
dem Behälterkonzept unter Umständen bei Namen für veränderbare
Objekte (z.B. Listen). Wenn nämlich der Wert eines Listenobjektes verändert wird, verweisen alle seine Namen auf das Objekt mit dem neuen
Wert. Aus Sicht der Behältermetapher kann es sein, dass bei einer Änderung des Inhalts von Variable a sich »auf magische Weise« auch der Inhalt
von Variable b ändert. Beispiel:
>>> a = [1, 2]
>>> b = a
>>> a[0] = 10
>>> print(b)
[10, 2]
Im Kapitel 2.4 gehen wir im Zusammenhang mit Listen detaillierter auf
diesen Punkt ein.
31
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
1.7
Die Standard-Typ-Hierarchie
In der Standard-Typ-Hierarchie werden die Typen von Objekten folgendermaßen strukturiert (in Klammern die Python-Typbezeichnung):
b None. Von diesem Datentyp gibt es nur ein einziges Literal, nämlich
den Wert None. Besitzt ein Objekt den Wert None, so wird damit zum
Ausdruck gebracht, dass es keinen Wert besitzt.
b Zahlen
b ganze Zahlen (int) beliebiger Länge, z.B. 12, 1234425562, -3
b Gleitkommazahlen (float), z.B. 12.34, 1.3E-12
b komplexe Zahlen (complex), z.B. 2.0 + 1.2j
b Wahrheitswerte (True und False) können auch numerisch interpretiert werden (1 und 0) und werden bei Python deshalb den
Zahlen zugerechnet (bool)
b Sequenzen sind endliche Folgen von Objekten, deren Elemente durch
nichtnegative ganze Zahlen indiziert sind. Wenn eine Sequenz die Länge n hat, so werden die Elemente mit den Indexen 0, 1, ..., als (n-1)
gekennzeichnet. Das i-te Item der Sequenz a wird mit a[i] selektiert.
b Zeichenketten (str), z.B. "Hallo", 'Python'
b Bytefolge (bytes), z.B. b'abc'
b Tupel (tuple), z.B. (1, 2, 3)
b Listen (list), z.B. [1, "Hallo", [1, 2]]
b Mengen (set, frozenset), z.B. set([1,2])
b Zuordnungen (Mappings) sind endliche Mengen von Objekten, die
durch (beinahe) willkürliche Werte indiziert werden. Das (momentan)
einzige Mapping unter den Standard-Typen ist das Dictionary (dict).
Beispiel: {'a':1, 'b':2, 'c':3}
b Aufrufbare Typen (callable types)
b Funktionen (function)
b Methoden (instancemethod)
b Klassen (class)
32
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.8 Literale für einfache Datentypen
b
b
b
b
Module
Klassen
Instanzen von Klassen (instance)
Dateien (file)
Python 2.x
Der Typ bytes ist neu bei Python 3. Python 2.x enthält den Typ long für
lange ganze Zahlen. Diesen Typ gibt es bei Python 3 nicht mehr.
1.8
Literale für einfache Datentypen
Literale sind Zeichenfolgen, die Daten repräsentieren. Sie sind also potenzielle Inhalte von Variablen. Beispiele für Literale sind 124, 1.45, "Python".
Literale kann man Datentypen zuordnen.
In vielen Programmiersprachen wie z.B. Java oder Pascal muss für eine
Variable im Rahmen einer Variablendeklaration ein Datentyp festgelegt
werden. Python kennt keine expliziten Typisierungen. Bei der Verarbeitung von Literalen muss das System aber wissen, um welchen Typ es sich
handelt, denn manche Operatoren repräsentieren unterschiedliche Funktionen, je nachdem auf welche Datentypen sie angewandt werden. So
bewirkt der Plusoperator + bei Zahlen eine Addition, bei Listen und Zeichenketten dagegen eine Konkatenation.
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> 'Kaffee' + 'pause'
'Kaffeepause'
Im Falle von Zahlen hängt der Typ des Rechenergebnisses davon ab, ob
ganze Zahlen (int) oder Gleitkommazahlen (float) addiert werden.
>>> 1.0 + 2.0
3.0
>>> 1 + 2
3
33
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
Damit die Typzuordnung gelingen kann, muss man dem Literal »ansehen«
können, um welchen Datentyp es sich handelt. Deshalb gibt es bei Python
strenge Regeln für den syntaktischen Aufbau der Literale eines Datentyps.
None
None ist ein Literal, das das leere Objekt bezeichnet. Besitzt eine Variable
den Wert None, wird damit zum Ausdruck gebracht, dass sie keinerlei Wert
beinhaltet. Das klingt paradox, ist aber manchmal ganz praktisch. So ist
es z.B. möglich, Funktionen mit eingeschränktem Definitionsbereich zu
definieren, ohne Laufzeitfehler zu riskieren. Eine solche Funktion liefert
den Wert None für alle Parameterwerte, die nicht in ihrem Definitionsbereich liegen.
None ist nicht etwa eine leere Menge oder die Zahl 0 oder ein leerer String
ohne ein einziges Zeichen. Nein, None ist wirklich nichts. Wird einer Variablen der Wert None zugewiesen und anschließend der Inhalt ausgegeben, so erhält man keine Ausgabe.
>>> b = None
>>> b
>>>
Beim Versuch, zu None etwas hinzuzuaddieren, gibt es eine Fehlermeldung.
>>> b = None
>>> b = b + 1
Traceback (most recent call last):
File "<pyshell#125>", line 1, in ?
b = b + 1
TypeError: unsupported operand types for +: 'NoneType' and 'int'
Zahlen
Für die Darstellung von Zahlen gibt es bei Python vier Typen, nämlich
ganze Zahlen beliebiger Länge (int), Gleitkommazahlen (float), komplexe Zahlen (complex) und Wahrheitswerte (bool). Weil die Wahrheits34
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.8 Literale für einfache Datentypen
werte True und False auch durch Zahlen 1 und 0 dargestellt werden können, rechnet man sie in der Python-Typhierarchie zu den ganzen Zahlen.
Ganze Zahlen
Die Syntax für Literale, die ganze Zahlen darstellen, lautet:
integer ::=
decimalinteger | octinteger | hexinteger
decimalinteger ::= nonzerodigit digit* | "0"+
octinteger
::= "0" ("o" | "O") octdigit+
hexinteger
::= "0" ("x" | "X") hexdigit+
bininteger
::= "0" ("b" | "B") bindigit+
nonzerodigit
::= "1"..."9"
digit
::= "0"..."9"
octdigit
::= "0"..."7"
hexdigit
::= digit | "a"..."f" | "A"..."F"
bindigit
::= "0" | "1"
Die Literale für ganze Zahlen können beliebig lang sein. Die technische
Grenze ist allein durch die Größe des Arbeitsspeichers gegeben. Eine
ganze Zahl kann als Dezimalzahl, Oktalzahl, Hexadezimalzahl oder Binärzahl dargestellt werden. Das System gibt ganze Zahlen jedoch immer als
Dezimalzahlen aus:
>>> 0b11001
25
>>> 0x1af
431
Das Vorzeichen ist übrigens nicht Teil des Zahlliterals. Eine negative Zahl
wie z.B. -123 wird als Term gesehen, der aus dem Minusoperator - und
der Zahl 123 besteht.
Dezimalzahlen
Eine Dezimalzahl darf nicht mit einer führenden Null beginnen. Die Ziffernfolge 09 liefert eine Fehlermeldung. Allerdings sind Folgen beliebig
vieler Nullen für die Zahl 0 erlaubt.
>>> 00000
0
35
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
Oktalzahlen
Oktalzahlen bestehen aus den Ziffern 0 bis 7 und müssen bei Python mit
der Ziffer 0 (nicht zu verwechseln mit dem großen Buchstaben O!) gefolgt
von dem Buchstaben O bzw. o beginnen. Beispiele für Oktalzahlen sind
0o123 und 0O302330, nicht aber 0071 (zwei führende Nullen).
Hexadezimalzahlen
Das Hexadezimalsystem verwendet 16 Ziffern, die durch die üblichen
Dezimalziffern 0 bis 9 und die sechs ersten Buchstaben des Alphabets dargestellt werden. Dabei repräsentiert A den numerischen Wert 10, B den
Wert 11 usw. und schließlich F den Wert 15. Bei Python beginnen Hexadezimal-Literale mit dem Präfix 0x oder 0X, wobei das erste Zeichen wiederum die Ziffer null (und nicht der Buchstabe O) ist. Beispiele für Hexadezimalzahlen sind 0x10e3 oder 0XD423f2, nicht aber ox3F (Buchstabe o
am Anfang).
Im interaktiven Modus einer Python-Shell kann man sich die Dezimalwerte von Oktal- und Hexadezimalzahlen ausgeben lassen:
>>> 0o10
8
>>> 0x10
16
Binärzahlen
Analog zu Hexadezimal- und Oktalzahlen werden Literale für Binärzahlen gebildet. Sie beginnen mit einer Null, danach kommt der Buchstabe
b bzw. B und eine Folge von Binärziffern, z.B. 0B101 oder 0b111.
Python 2.x
Bei Python 2.x gibt es zwei Typen für ganze Zahlen: plain integer (int)
und long integer (long). Die Literale vom Typ int umfassen alle ganzen
Dezimalzahlen von 0 bis mindestens 2147483647. Sie werden intern durch
schnelle 32-Bit-Arithmetik verarbeitet. Bei Prozessoren, die größere
Wortlängen verarbeiten können, kann dieser »schnelle« Integer-Bereich
auch größer sein. Long-integer-Literale besitzen nach der Ziffernfolge
36
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.8 Literale für einfache Datentypen
ein angehängtes KLEINES l oder großes L. Es wird empfohlen, das große L
zu verwenden, da der Buchstabe l leicht mit der Ziffer 1 verwechselt werden kann.
Beispiele:
1L 1249443443446674588568686L
Ganze Zahlen, die größer als 2147483647 sind, werden vom System automatisch als long integers interpretiert. Es tritt also kein Fehler auf, wenn
in einer Anweisung bei einer langen Ziffernfolge das angehängte L vergessen wird.
>>> 2147483647
2147483647
>>> 2147483648
2147483648L
Oktalzahlen beginnen bei Python 2.x zwar mit einer Null, danach kommt
aber kein Buchstabe O, sondern direkt Oktalziffern, z.B. 0270. Besondere
Literale für Binärzahlen gibt es bei Python 2.x nicht.
Gleitkommazahlen
Gleitkommazahlen (floating point numbers) sind Literale zur Darstellung
von Dezimalbrüchen. Die Grammatik für Gleitkommazahlen lautet:
floatnumber
pointfloat
exponentfloat
intpart
fraction
exponent
::=
::=
::=
::=
::=
::=
pointfloat | exponentfloat
[intpart] fraction | intpart "."
(intpart | pointfloat) exponent
digit+
"." digit+
("e" | "E") ["+" | "-"] digit+
Eine Gleitkommazahl kann als Dezimalbruch mit einem Punkt oder in
Exponentialschreibweise durch Angabe von Mantisse und Exponent dargestellt werden.
Gültige Gleitkommazahlen sind 3.14 oder .45 oder 0.23 oder 0.00012
oder 2., nicht aber 2 (Punkt fehlt).
Für rationale Zahlen, die sehr nahe bei 0 liegen oder sehr groß sind, wird
die Exponentialschreibweise verwendet. Dabei wird die Zahl durch das
37
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
Produkt einer rationalen Zahl m (Mantisse) mit einer Zehnerpotenz mit
dem Exponenten e dargestellt:
z = m*10e
Ein Gleitkomma-Literal in Exponentialschreibweise (exponentfloat)
besteht aus einem Dezimalbruch oder einer ganzen Zahl (ohne Punkt) für
die Mantisse, gefolgt von dem Buchstaben e oder E, einem Vorzeichen (+
oder -), das bei positiven Exponenten auch weggelassen werden kann,
und schließlich einer ganzen Zahl als Exponenten.
Gültige Literale sind:
1.0e-10
entspricht der Zahl 0.0000000001
2.1E+7
entspricht der Zahl 21000000
.2e0
entspricht der Zahl 0.2
001e2
entspricht der Zahl 100
Ungültig sind:
0x10E1 (Hexadezimalzahl als Mantisse).
0.1-E7 (Minuszeichen vor dem E)
1.2e0.3 (keine ganze Zahl als Exponent)
Man beachte, dass mehrere führende Nullen erlaubt sind. Mantisse und
Exponent sind immer Dezimalzahlen (auch bei einer führenden Null) und
niemals Oktal- oder Hexadezimalzahlen.
Die Genauigkeit der internen Darstellung von Gleitkommazahlen ist auf
eine feste Anzahl von Stellen begrenzt. Gibt man längere Ziffernfolgen
ein, so werden die letzten Stellen einfach abgetrennt.
>>> 1.2345678901234567890
1.2345678901234567
Die begrenzte Genauigkeit der internen Darstellung erkennen Sie auch
an folgendem Experiment:
>>> 0.6 / 3
0.1999999999999999
38
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.8 Literale für einfache Datentypen
Das Rechenergebnis, die rationale Zahl 0.2, kann durch eine PythonGleitkommazahl nicht präziser angenähert werden.
Es gibt aber ein spezielles Modul für Dezimalarithmetik, mit der sich diese
Ungenauigkeiten kontrollieren lassen (siehe Kapitel 17.3).
Imaginäre Literale
Komplexe Zahlen werden in der Mathematik als Summe aus einem Realund einem Imaginärteil beschrieben:
c = a + b*i
Dabei bezeichnet der Buchstabe i die Wurzel aus –1. In der Technik verwendet man meist den Buchstaben j anstelle von i, um Verwechslungen
mit dem Symbol für die Stromstärke zu vermeiden. Komplexe Zahlen
spielen in der Elektrotechnik bei der mathematischen Beschreibung von
Wellen eine große Rolle. Bei Python gibt es kein eigenes Literal für komplexe Zahlen, sondern nur für den Imaginärteil komplexer Zahlen. Oder
anders ausgedrückt: Imaginäre Literale stellen komplexe Zahlen mit dem
Realteil 0 dar. Für ihre Syntax gibt es die folgende Regel:
imagnumber ::= (floatnumber | intpart) ("j" | "J")
Das heißt, ein imaginäres Literal besteht aus einer ganzen Zahl oder Gleitkommazahl, der der Buchstabe j (oder J) angehängt ist. Beispiele sind:
0.3j
1.2e-3J 20j
Wahrheitswerte
Seit der Python-Version 2.3 gibt es einen eigenen Datentyp bool für logische Wahrheitswerte. Wahrheitswerte werden durch die Literale True
(logisch »wahr«) und False (logisch »falsch«) repräsentiert. Achten Sie auf
die Schreibweise! Beide Literale beginnen mit großen Anfangsbuchstaben. Mit Objekten vom Typ bool kann man logische Operationen durchführen (siehe Kapitel 5).
>>> a = True
>>> not a
False
39
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
>>> a or a
True
Darüber hinaus besitzen Objekte der Standard-Typen neben ihrem
»eigentlichen« Wert auch einen Wahrheitswert. Leere Objekte tragen den
Wahrheitswert False und nicht leere Objekte den Wahrheitswert True.
Mit der Standardfunktion bool() können Sie den Wahrheitswert eines
Objektes oder eines Ausdrucks ermitteln.
>>> bool(0)
False
>>> bool(100)
True
>>> bool (10+1-3)
True
1.9
Namensräume – lokale und
globale Namen
In einem Namensraum werden Bindungen von Namen an Objekte definiert. Zu jedem Programmblock (Funktionskörper, Klassendefinition oder
Modul) gibt es zwei Namensräume (name spaces), einen lokalen und
einen globalen Namensraum. Jeder Namensraum wird durch ein Dictionary implementiert. Es ordnet Bezeichnern (Namen) Objekte zu. Die lokalen und globalen Namensräume können mit den Kommandos locals()
und globals() abgefragt werden.
Wenn Sie mit IDLE eine Python-Shell öffnen und als Erstes diese beiden
Kommandos eingeben, erhalten Sie folgendes Ergebnis:
>>> globals()
{'__name__': '__main__', '__package__': None,
'__doc__': None,
'__loader__': <class '_frozen_importlib.BuiltinImporter'>,
'__builtins__': <module 'builtins'>}
>>> locals()
{'__name__': '__main__', '__package__': None,
40
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.9 Namensräume – lokale und globale Namen
'__doc__': None,
'__loader__': <class '_frozen_importlib.BuiltinImporter'>,
'__builtins__': <module 'builtins'>}
Sie erkennen zunächst einmal, dass es auf dieser obersten Ebene des
Hauptprogramms keinen Unterschied zwischen lokalen und globalen
Objekten gibt. Die beiden Dictionaries beinhalten unter anderem folgende Namensbindungen:
b Die Variable __name__ hat den Inhalt '__main__'. Das besagt, dass der
Programmtext dieses Blocks direkt ausführbar ist (Hauptprogramm).
b Die Variablen __doc__ und __package__ besitzen keinen Inhalt.
Namensräume können auf verschiedene Weise erweitert werden:
b Eingabe einer Zuweisung, in der ein Variablenname vorkommt
b Definition einer Funktion
b Import von Modulen oder Objekten aus Modulen
Probieren Sie im interaktiven Modus Folgendes aus:
>>> a = 1
>>> import math
>>> globals()
{'__name__': '__main__', '__package__': None, 'math': <module
'math' (built-in)>, '__doc__': None, 'a': 1, '__loader__':
<class '_frozen_importlib.BuiltinImporter'>, '__builtins__':
<module 'builtins'>}
Sie sehen, dass die Namen a und math dem globalen Namensraum zugefügt worden sind. Der Aufruf locals() liefert genau das gleiche Dictionary.
Unterschiedliche globale und lokale Namensräume gibt es z.B. bei Funktionen. Beispiel:
>>> def test():
x = 123
print(locals())
print(globals())
>>> test()
41
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1 Basiskonzepte von Python
{'x': 123}
{'__name__': '__main__', '__package__': None, 'math': <module
'math' (built-in)>, '__doc__': None, 'a': 1, 'test': <function
test at 0x02267858>, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <module 'builtins'>}
Man erkennt, dass der lokale Namensraum der Funktion test() allein die
Variable x mit dem Inhalt 123 enthält. Sie ist eine lokale Variable. Der
Name der Funktion (test) gehört zum globalen Namensraum.
Die global-Anweisung
Programmblöcke und die zugehörigen Namensräume sind ineinander
verschachtelt. Wenn in einem Programmblock ein Name verwendet wird,
sucht das Laufzeitsystem zunächst im lokalen Namensraum des innersten
Blocks nach dem zugehörigen Objekt.
Betrachten Sie folgendes Beispiel:
>>> def test():
x = 1
print(x)
>>> x = 2
>>> test()
1
>>> x
2
Offenbar gibt es zwei Variablen x. Die Funktion test() verwendet eine
lokale Variable x, die sie auf den Wert 1 setzt. Die andere Variable x, der
auf der Ausführungsebene der Wert 2 zugewiesen worden ist, wird durch
test() nicht verändert. Beide Variablen haben nach außen den gleichen
Namen, sind aber unterschiedliche Objekte in zwei unterschiedlichen
lokalen Namensräumen.
Wenn die Funktion test() auf eine Variable des übergeordneten Blocks
(damit ist der Programmtext gemeint, in dem die Funktion aufgerufen
worden ist) zugreifen soll, muss sie als global deklariert werden. Das
geschieht in einer global-Anweisung. Zu beachten ist, dass diese Anwei-
42
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
1.9 Namensräume – lokale und globale Namen
sung innerhalb des Funktionskörpers steht und nicht etwa im übergeordneten Block. Beispiel:
>>> def test():
global x
x = 1
print(x)
>>> x = 2
>>> test()
1
>>> x
1
Man sieht den Effekt der global-Anweisung: Es gibt nur noch eine (globale) Variable x. Die Funktion test() überschreibt nun den Inhalt der
Variablen x, sie trägt jetzt am Ende den Wert 1.
Beachten Sie: Ob eine Variable global ist, wird innerhalb einer Funktion
entschieden. Einer Funktion kann nicht »von außen« aufgezwungen werden, eine globale Variable zu übernehmen. Damit gibt es einen gewissen
Schutz vor unbemerkten Seiteneffekten anderer Funktionen. Wenn Sie
den Programmtext einer Funktion betrachten, können Sie sich durch
Inspektion der global-Anweisungen einen Überblick über globale Variablen verschaffen.
43
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
S
Stichwortverzeichnis
A
Abfangen von Laufzeitfehlern 139
abs() 165
abspath() 283
access() 274
addHandler() 227
Addition 97
Adjazenzliste 66
after() 477
after_cancel() 478
Aggregat 463
Aktueller Parameter 146
Aliasieren 59
Aliasierung 59
alpha_composite() 568
and 106
Anweisung 109
Anweisungsblock 145
append() 60
appendChild 593
appendChild() 593
argv 263
Array 67 365
as 140
ASCII 337
ascii_letters 341
ascii_lowercase 341
ascii_uppercase 342
asctime() 290
assert 110 219
Attribut 306 308
abgeleitetes Attribut 309
Klassenattribut 308
,
,
,
Objektattribut 309
öffentlich 310
privat 311
Ausdruck 111
Ausnahme 120
Ausnahmen 209
Auswahlfeld 508
Authentifizierung 458
B
BaseHTTPServer 415
basename() 283
basicConfig() 224
Basisklasse 321
Beep() 574
Beliebige Anzahl von Parametern 152
Bezeichner 26
Schlüsselwort 26
Unterstrich 27
Bild 515
einbinden 555
Binäre arithmetische Operatoren 97
Binärzahl 36
bind() 478
Binden 546
blend() 569
bool 39
bool() 166
Botschaft 303
break 111 137 138
buffer () 168
Button 480
Bytestring 52
,
–
633
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
C
Canvas 481
capitalize() 335
center() 335
cgi.FieldStorage 400
CGIHTTPServer 415
CGI-Skript 393
Ausgabe 394
cgi.FieldStorage 400
debuggen 406
erste Zeile 394
GET-Methode 396
Installation 404
POST-Methode 396
cgitb 406
CGI-Webserver 415
chdir () 275
Checkbutton 494
childNodes 592
chmod() 275
choice 508
choice() 382
chr() 169
clear() 78
Client-Server-System 393
close() 246
closed 246
cmath 368
cmp() 170
compile() 171 359
complex () 172
connect() 436
Context 372
continue 112 137 138
Cookie 407
coords() 486
copy() 78 560
count() 60 335
create_arc() 487
,
,
,
,
–
create_bitmap() 489
create_image() 489
create_line() 490
create_oval() 492
create_polygon() 492
create_rectangle() 493
create_text() 493
create_window() 494
createElement() 601
createTextNode() 601
CRITICAL 223
crop() 560
ctime() 291
Cursorobjekt 438
Customizing 315
D
date 296
Datei siehe File
Datenbank 427
Cursorobjekt 438
Definition 430
erstellen 430
MySQLdb 435
SELECT 439
Tabelle erzeugen 431
Verbindung zum Datenbankserver
436
Verbindungsobjekt 437
Datentyp 33
datetime 295
Datum 289
DEBUG 223
decimal XE 369
decode() 52 335
Decorator 161
def 145
DefaultContext 373
del 112
,
634
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
delattr() 172
Dezimale Gleitkomma-Arithmetik 369
Dezimalzahl 35
Dialogbox 544
dict() 173
Dictionary 75
clear() 78
copy() 78
get() 79
keys() 80
popitem() 83
Schlüssel 75
setdefault() 83
update() 83
values() 84
difference() 91
digest() 448
Digitale Signatur 445
digits 342
dir() 174
dirname() 284
displayhook() 264
Division 98
divmod() 174
Docstring 145
Document 600
Document Object Model siehe DOM
documentElement 601
DOM 586
createTextNode() 601
Document 600
documentElement 601
Element 601
getElementsByTagName() 601
Knoten 586
Knoten einfügen 597
Node 591
tagName 602
Text 605
DOM-Objekt 590
dump() 255
dumps() 256
E
Eingabefeld 398
Einrückung 24
Einrückungsfehler 25
Einwegfunktion 445
Element 601
elif 130
else 130
E-Mail 418 421
Endlosschleife 139
endswith() 337
Entity-Typ 428
Entry 498
environ 276
Epoche 289
ER-Diagramm 428
ERROR 223
Erweiterte Zuweisung 125
Escape-Sequenz 50
EVA-Konzept 233
eval() 175
Event 546
binden 546
Taste 550
Eventhandler 552
Event-Modifizierer 550
Event-Sequenz 548
Event-Typ 549
exc_info() 265
except 140 214
Exception 210
exception 142
Exception-Klasse 214
exec 126
execfile() 176
exists() 284
exit() 266
,
,
635
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
Exklusives Oder 102
expovariate() 382
extend() 61
ExtendedContext 375
F
False 39
Fehler 209
Exception 210
Syntaxfehler 209
Feldname 347
File
close() 246
closed 247
flush() 247
isatty() 247
Iterationen 253
mode 248
read() 248
readline() 249
readlines() 249
seek() 250
tell() 251
truncate() 251
write() 252
FileHandler 230
Filter 570
filter () 176
finally 142
find() 338
findall() 359
firstChild 592
Flache Kopie 78
flash() 481
float() 177
flush() 247
for 133
Formaler Parameter 145
Format
für Meldungen 231
format() 338
Formatierung 344
Formatierungsoperator % 238
Formatierungsstring 238
Formatspezifikation 348
Formatstring 346
Frame 499
from 116 324
frozenset 88
frozenset() 179
ftplib 412
FTP-Server 412
Funktion 145
lokale 155
rekursive 153
Standardfunktionen 165
Funktionskopf 145
Funktionskörper 145
,
G
Ganze Zahl 35
Ganzzahlige Division 99
gauss() 383
Generatorfunktion 122 156
get() 79
getatime() 284
getattr() 179
getAttribute() 602
getcontext() 372
getcwd() 276
getElementsByTagName() 601 603
getenv() 277
getfirst() 402
getlist() 403
getLogger() 227
getmtime() 284
getopt() 235
getpixel() 561
getrecursionlimit() 268
getrefcount () 267
,
–
636
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
getsize() 285
getstate() 385
getvalue() 404
Gierig 354
Gleitkommazahlen 37
global 43 114
Globale Variable 148
Globaler Name 40
globals() 180
gmtime() 291
Grafische Benutzungsoberfläche 461
Dialogbox 544
Kontrollvariable 543
Layout-Manager 532
Menü 503
Tk 531
Tk-Icon 532
Widgets 462
Grafische Benutzungsoberflächen
Menü 509
Graph 66
grid() 539
Grid-Layout-Manager 533
GUI siehe Grafische Benutzungsoberfläche
,
H
Handler 229
hasattr() 180
hasAttribute() 602
hasAttributes() 593
hasChildNodes() 593
hash() 180
Hashing-Objekt 446
hashlib 445
help() 181
hex() 181
Hexadezimalzahl 36
hexdigits 342
Hook 264
HTML-Formular 396
Checkbox 399
Eingabefeld 398
Radiobutton 398
HTTP_COOKIE 407
HTTP-Server 393
I
id () 182
identifier siehe Bezeichner
Identität 28
if 129
Image 557
alpha_composite() 568
blend() 569 570
copy() 560
crop() 560
Filter 570
format 558
getpixel() 561
load() 561 566
mode 558
paste() 561
resize() 564
save() 562
show() 562
size 558
Image.open() 557
ImageFilter 570
IMAP4 416
imaplib 416
import 115 324
in 46 104
Index 526
index() 61
IndexError 347
Infinity 372
INFO 223
–
,
,
,
637
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
inorder 215
input() 182 233
insert() 62
insertBefore() 593
insertBefore(newChild, 593
Instanz 306
int() 184
Interaktiver Modus 19
Internet Message Protokoll 416
Internet-Programmierung 411
intersection() 92
Inversion 96
Inversionsoperator
~ 96
invoke() 481
is 105
is not 105
isatty() 247
isdir() 285
isfile() 285
isinstance () 185
islink() 285
issabs() 285
issubclass() 185
iter() 186
Iteration 133 253
Iterator 156 158
Generatorfunktion 156
in for-Anweisung 135
iter() 186
reversed() 198
sorted() 200
,
,
J
,
,
join() 286 339
jumpahead() 385
K
Kalenderdatum 295
key 65
key siehe Schlüssel
keys() 80
Klasse 304
Klassenattribut 308
Klassenbibliothek 324
Klassendiagramm 306
Klonen 60
Knoten 67 586
Komplexe Zahl 39
Konstruktor 305
Kontext 372
Kontrollstruktur 129
elif 130
else 130
Endlosschleife 139
for 133
if 129
try 139
while 137
Kontrollvariable 543
Konvertierungsspezifikator 344
Kurze Zeichenkette 49
,
L
Label 500
Lambda-Form 160
Lange Zeichenkette 49
lastChild 592
Latin-1 337
Layout-Manager 532
len() 187
List Comprehension 58
list() 187
Listbox 500
listdir () 277
Liste 56
Aliasieren 59
append() 60
count() 60
erzeugen 57
638
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
extend() 61
index() 61
insert() 62
Klonen 60
List Comprehension 58
pop() 62
remove () 62
reverse() 62
sort() 63
sum() 202
Listen-Display 57
Literal 33
load() 566
loads() 256
locals() 188
localtime() 292
logging 222
basicConfig() 224
Format 231
getLogger() 227
Handler 229
logging level 227
Logische Fehler 209
Logischer Operator 106
Lokale Funktion 155
Lokale Variable 148
Lokaler Name 40
Long integer 36
long() 206
lstrip() 339
max() 189
MD5 445
Mehrfachverzweigung 130
Menge 87 104
frozenset() 179
set() 199
Menu 503
Menubutton 512
MessageBeep() 574
Methode 311
min() 189
mkdir() 277
mkdirs() 278
mktime() 292
mode 248
Modul 324 611
Modulo 99
Modulo-Operator 99
Monat 290
Multilisten-Struktur 58
Multiplikation 98
MySQL 428
MySQL Monitor 431
MySQLdb 435
,
,
N
Nachbedingungen 219
Name 30
Namensraum 40
NaN 372 377
new() 570
next() 157 159
nextSibling 592
Node 591
nodeType 592
None 34
normcase() 286
not 106
not in 104
,
,
M
Magic line 22
mainloop() 465 532
map() 188
Marke 527
Master-Slave-Hierarchie 465
match() 360
Match-Objekt 362
math 378
,
639
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
O
Oberklasse 321
Objekt 28
änderbar 28
unveränderbar 28
Objektattribut 309
Objektdiagramm 306
Objektorientierte Programmierung
303
oct() 191
octdigits 342
Oktalzahl 36
OOA 303
OOD 303
OOP
statische Methode 319
OOP siehe Objektorientierte Programmierung
open() 191
Operator 95
- 96
% 99
& 101
* 98
** 100
+ 96
/ 98
// 99
<< 101
>> 101
^ 102
| 102
binär 97
Boole’scher O. 106
in 46 104
is 105
logisch 106
unär 96
Vergleich 102
,
or 106
ord() 192
os 271
os.name 278
P
pack() 533
Packer 532
Paket 327
Parameter
aktueller 146
beliebige Anzahl 152
formaler 145
Parameterliste 145
Parameterübergabe 147
parentNode 593
parse() 591
parseString() 591
Parsing 590
pass 119
Passwort 449
paste() 561
path 269
Performance 363
Sequenzen 71
PhotoImage 515
pickle 253
Pickler 254 257
PIL 556
PIL.ImageTk 563
Pillow 556
pip 555
place() 536
Placer 533
PlaySound() 575
Polymorphismus 312
pop() 62
POP3-Protokoll 418
popitem() 83
,
640
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
poplib 418
Positionsargument 150
pow() 193
pprint() 241
PrettyPrinter 242
previousSibling 593
Primärschlüssel 429
print() 127
printable 342
Profiler 154
Property 317
Prozedur 153
Prozess 577
Prozess-Management 271
PSF siehe Python Software Foundation
punctuation 342
putenv() 278
PyPI 555
Python Image Library 556
Python Package Index 555
Python Software Foundation 13
Python-Version
abfragen 269
Q
Quicksort 221
R
r 53
Radiobutton 516
raise 120 213
randint() 386
random 380
random() 386
range() 134 196
Raw-String 53
re 351
read() 248
readline() 249
readlines() 249
,
,
Regulärer Ausdruck 351
compile() 359
findall() 359
Funktionen 359
match() 360
Match-Objekt 362
RE-Objekt 361
search 360
split() 361
sub() 361
Syntax 352
Rekursive Funktion 153
Relation 429
remove () 62
removeChild 593
removeChild() 596
removeChild(oldChild) 593
removedirs() 278
rename() 278
renames() 279
RE-Objekt 361
replace() 340
repr() 197
resize() 564
return 121
reverse() 62
reversed() 198
RFC 411
rmdir() 279
round() 198
S
save() 562
Scale 518
Schablone 342
Schleife 137
Schleifenbedingung 138
Schleifeninnere 137
Schlüssel 75
Schlüsselwort 27
641
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
Scrollbar 521
search() 360
seed() 387
seek() 250
Selbstdokumentation 220
SELECT 439
Sequenz
gemeinsame Operationen 45
in 46
indizieren 46
Konkatenation 46
Länge 46
not in 46
Slicing 47
sum() 202
Serialisierung 253
set 87
set() 199
setattr() 199
setAttribute() 602
setcontext() 374
setdefault() 83
setrecursionlimit() 268
setstate() 388
Shell 19
show() 562
shuffle() 386
Signal 375
sleep() 292
slice() 200
Sliceliste 47
Slicing 47
SMTP 421
smtplib 421
Sommerzeit 291
sort() 63
sorted() 200
Sortieren 64
split() 286 340 361
,
,
splitdrive() 287
splitext() 287
Standardfunktion 165
Standard-Typ-Hierarchie 32
start_new_thread() 578
stat() 279
staticmethod() 319
Statische Methode 319
stderr 270
stdin 270
stdout 270
StopIteration 157
str() 201
StreamHandler 230
strftime() 293
String 48 331
Escape-Sequenz 50
Formatierung 344
Konstanten 341
Konvertierungsspezifikator 344
kurze Zeichenkette 49
Lange Zeichenkette 49
Raw String 53
Unicode 51
Strings
Performance 363
sub() 361
Subtraktion 97
Suite 24
sum() 202
Syntaxfehler 209
sys 261
sys.argv 234
sys.version 268
,
T
Tabelle 431
Tag 528
tagName 602
642
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
Tastenname 550
Teilmenge 93
tell() 251
Telnet 424
telnetlib 424
Template 342
Term 111
Text 523
Texteditor 529
Thread 577
threading 577
time 298
time() 294
timedelta 295
Timer 582
Tk 531
tkFileDialog 545
Tk-Icon ändern 532
tkinter 461
tkMessageBox 544
Ton 555
toprettyxml() 594 599
toxml() 594 598
Tracing 223
Trap 377
True 39
truncate() 251
try 139 213
Tupel 54
tuple() 203
Typ 29
None 34
Standard-Typ-Hierarchie 32
type() 203 204
,
,
–
U
Überladen 312
Umlaut 337
unendlich 372
unichr() 206
,
Unicode 51
unicode() 54 207
uniform() 388
union() 92
Unix
Programmausführung 22
unlink() 594
Unpickler 254 257
Unterklasse 321
Unterstrich 27
update() 83 447
urllib 259
urlopen() 259
UTC 289
UTF-8 337
,
,
,
V
values() 84
van Rossum 13
Variable 31
globale 148
lokale 148
vars() 204
Verbinden von Zeilen 23
Verbindungsobjekt 437
Vererbung 321
Vergleich 102
Verschachtelte Liste 58
Vorbedingungen 219
Voreingestellter Parameterwert 149
W
Wahrheitswert 39
WARNING 223
Webcam 559
while 137 214
Whitespace 342
Widget 462
Auswahlfeld 508
Bitmap 470
,
643
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726
Stichwortverzeichnis
Button 480
Canvas 481
Checkbutton 494
Cursor 471
Entry 498
Farben 469
Fokus 473
Fonts 469
Frame 499
Kontrollvariable 543
Koordinaten 468
Label 500
Längeneinheiten 467
Listbox 500
mainloop() 465
Master-Slave-Hierarchie 465
Menu 503
Menubutton 512
Option 466
Radiobutton 516
Rahmen 472
Scale 518
Scrollbar 521
Standard-Methoden 476
Text 523
Windows 21
Winsound 573
Wochentag 290
write () 252
writelines() 252
X
XML 585
xml.dom.minidom 585
xrange() 134 207
,
Y
,
yield 121 156
Z
Zahl 34
ganze 35
Zeichenkette 48 49
Zeichenkette siehe String
Zeile
Einrückung 24
logische Zeile 23
physische Zeile 23
Verbinden von Zeilen 23
Zeilenstruktur 23
Zeit 289
Zeitabschnitt 295
zip() 205
Zufallsgenerator 380
Zugriffsrechte 271
Zusicherung 110
Zuweisung 122
–
644
© des Titels »Python Ge-Packt« (ISBN 9783826687266) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/8726