Einstieg in Python 3

Thomas Theis
Einstieg in Python 3
e·A
.,.
Gal ileo Press
• e
Liebe Leserin, lieber Leser,
mit der Programmiersprache Python haben Sie eine gute Wahl getroffen: Sie ist
nicht nur leicht zu lernen, sie bietet Ihnen später auch das Potenzial für anspruchsvollere Projekte.
Dieses Buch wird Sie dabei auf Ihrem Weg von Anfang an begleiten. Schritt für
Schritt und jederzeit verständlich erlernen Sie zunächst anhand vieler kleiner Beispiele die Grundlagen der Programmierung. Sie werden daher im Handumdrehen
in der Lage sein, Ihre ersten eigenen Python-Programme zu schreiben, selbst wenn
Sie vorher noch nie programmiert haben sollten. Im weiteren Verlauf des Buchs
macht Sie unser Autor Thomas Theis dann nach und nach natürlich auch mit den
fortgeschritteneren Themen der Python-Programmierung vertraut - selbstverständlich alles aktuell zur neuen Version Python 3.
Im Vordergrund steht dabei stets die Praxis, denn auch mit dem besten Buch lernen Sie Python nur, indem Sie selbst damit programmieren. Aus diesem Grund bietet Ihnen das Buch nicht nur eine Vielzahl spielerischer Beispiele, sondern auch
zahlreiche Übungen, mit denen Sie Ihr neu gewonnenes Wissen direkt austesten
können. Alles, was Sie dafür benötigen, finden Sie auf der beiliegenden CD, so dass
Sie sofort loslegen können.
Dieses Buch wurde mit großer Sorgfalt geschrieben, geprüft und produziert. Sollte
dennoch einmal etwas nicht so funktionieren, wie Sie es erwarten, freue ich mich,
wenn Sie sich mit mir in Verbindung setzen. Ihre Kritik und konstruktiven Anregungen, aber natürl ich auch I hr Lob sind uns jederzeit herzl ich will kommen!
Viel Spaß mit Python wünscht Ihnen nun
Ihre Christine Siedle
Lektorat Galileo Computing
ch ristine [email protected]
www.galileocomputing.de
Galileo Press· Rheinwerkallee 4·53227 Bonn
Auf einen Blick
1
Einführung ............................................................................
13
2
Erste Sch ritte ........................................................................
17
3
Programmierkurs ...................................................................
31
4
Datentypen ...........................................................................
77
5
Weiterführende Programmierung ..........................................
131
6
Objektorientierte Programmierung ........................................
179
7
Neues in Python 3 ................................................................
195
8
Verschiedene Module ...........................................................
199
9
Dateien.................................................................................
225
10
Internet ................................................................................
257
11
Datenbanken ........................................................................
291
12
Benutzeroberflächen
309
13
Lösungen ..............................................................................
379
3
Der Name Galileo Press geht auf den italienischen Mathematiker und Philosophen Galileo
Galilei (1564-1642) zurück. Er gilt als Gründungsfigur der neuzeitlichen Wissenschaft und
wurde berühmt als Verfechter des modernen, heliozentrischen Weltbilds. Legendär ist sein
Ausspruch Eppur se muove (Und sie bewegt sich doch). Das Emblem von Galileo Press ist der
Jupiter, umkreist von den vier Galileischen Monden. Galilei entdeckte die nach ihm benannten
Monde 1610.
Gerne stehen wir Ihnen mit Rat und Tat zur Seite:
[email protected] bei Fragen und Anmerkungen zum Inhalt des Buches
[email protected] für versandkostenfreie Bestellungen und Reklamationen
[email protected] für Rezensions- und Schulungsexemplare
Lektorat Judith Stevens-Lemoine, Christine Siedle
Fachgutachten Carsten Reimer
I<orrektorat Bettina Mosbach
Cover Barbara Thoben, Köln
Titelbild Barbara Thoben, Köln
Typografie und Layout Vera Brauner
Herstellung Julia Bach
Satz Typographie & Computer, Krefeld
Druck und Bindung Bercker Graphischer Betrieb, Kevelaer
Dieses Buch wurde gesetzt aus der Linotype Syntax Serif (9,25/13,25 pt) in FrameMaker.
Gedruckt wurde es auf chlorfrei gebleichtem Offsetpapier.
Bibliografische Information der Deutschen Bibliothek
Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie;
detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.
ISBN
978-3-8362-1406-3
© Galileo Press, Bonn 2009
2., aktualisierte Auflage
Das vorliegende Werk ist in all seinen Teilen urheberrechtlieh geschützt. Alle Rechte vorbehalten, insbesondere das Recht
der Übersetzung, des Vortrags, der Reproduktion, der Vervielfältigung auf fotomechanischem oder anderen Wegen und der
Speicherung in elektronischen Medien. Ungeachtet der Sorgfalt, die auf die Erstellung von Text, Abbildungen und Programmen verwendet wurde, können weder Verlag noch Autor, Herausgeber oder Übersetzer für mögliche Fehler und deren Folgen eine juristische Verantwortung oder irgendeine Haftung übernehmen. Die in diesem Werk wiedergegebenen Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. können auch ohne besondere Kennzeichnung Marken sein und als
solche den gesetzlichen Bestimmungen unterliegen.
Inhalt
1
2
Einführung ................................................................................
1.1
Vorteile von Python .....................................................................
13
1.2
1.3
Verbreitung von Python ...............................................................
Aufbau des Buchs ........................................................................
14
14
1.4
Übungen .....................................................................................
15
1.5
Installation von Python ................................................................
16
Erste Schritte ...........................................................................
17
2.1
17
17
2.2
2.3
3
13
Python als Taschenrechner ...........................................................
2.1.1
Eingabe von Berechnungen .............................................
2.1.2
Addition, Subtraktion und Multiplikation ........................
18
2.1.3
Division, Ganzzahldivision und Modulo ...........................
18
2.1.4
2.1.5
Rangfolge und Klammern ................................................
Variablen und Zuweisung ................................................
19
20
Erstes Programm ..........................................................................
2.2.1
Hallo Welt ......................................................................
21
21
2.2.2
Eingabe eines Programms ................................................
Speichern und Ausführen .............................................................
2.3.1
Speichern ........................................................................
22
22
22
2.3.2
Ausführen unter Windows ..............................................
23
2.3.3
Ausführen unter Linux .....................................................
27
2.3.4
2.3.5
Kommentare...................................................................
Verkettung von Ausgaben ...............................................
27
28
2.3.6
Lange Ausgaben ..............................................................
28
Programmierkurs ......................................................................
31
3.1
Ein Spiel programmieren ..............................................................
3.1.1
Das fertige Spiel ..............................................................
31
31
3.1.2
Der Weg zum fertigen Spiel.............................................
31
3.1.3
Mögliche Erweiterungen .................................................
32
Variablen und Operatoren ...........................................................
3.2.1
Berechnung und Zuweisung ............................................
3.2.2
Eingabe einer Zeichen kette .............................................
32
32
33
3.2
3.2.3
Eingabe einer Zahl...........................................................
33
3.2.4
Spiel, Version mit Eingabe ...............................................
35
3.2.5
Zufallszahlen ...................................................................
36
5
Inhalt
3.3
3.4
3.5
3.6
6
37
3.3.1
Vergleichsoperatoren ......................................................
38
3.3.2
3.3.3
3.3.4
3.3.5
Einfache Verzweigung .....................................................
38
Spiel, Version mit Bewertung der Eingabe .......................
Mehrfache Verzweigung ..................................................
Logische Operatoren .......................................................
39
40
42
3.3.6
Mehrere Vergleichsoperatoren ........................................
3.3.7
3.3.8
Spiel, Version mit genauer Bewertung der Eingabe ..........
44
45
Rangfolge der Operatoren .............................. .................
Schleifen......................................................................................
46
47
3.4.1
for-Schleife .....................................................................
47
3.4.2
3.4.3
Schleifenabbruch mit break .............................................
Geschachtelte I<ontrollstrukturen ....................................
48
48
3.4.4
Spiel, Version mit for-Schleife und Abbruch ....................
50
3.4.5
3.4.6
3.4.7
3.4.8
for-Schleife mit rangeO ....................................................
Spiel, Version mit rangeO ................................................
while-Schleife .................................................................
Spiel, Version mit while-Schleife und Zähler ....................
51
54
56
57
Fehler und Ausnahmen ................................................................
58
3.5.1
Basisprogramm ................................................................
58
3.5.2
3.5.3
Programmabbruch vermeiden .........................................
Fehler abfangen ..............................................................
59
61
3.5.4
3.5.5
Exkurs: Schleifenfortsetzung mit continue .......................
Spiel, Version mit Ausnahmebehandlung ........................
62
63
Funktionen und Module ..............................................................
3.6.1
Einfache Funktionen ........................................................
3.6.2
Funktionen mit einem Parameter ....................................
3.6.3
Funktionen mit mehreren Parametern .............................
65
66
68
69
3.6.4
Funktionen mit Rückgabewert .........................................
70
3.6.5
Spiel, Version mit Funktionen .........................................
Das fertige Spiel...........................................................................
71
72
Datentypen ..............................................................................
77
4.1
77
3.7
4
Verzweigungen ............................................................................
Zahlen
4.1.1
4.1.2
Ganze Zahlen ................................................................. .
Zahlen mit Nachkommastelien ...................................... ..
77
79
4.1.3
Operatoren.....................................................................
4.1.4
4.1.5
4.1.6
Rundung und I<onvertierung ...........................................
Modul math ....................................................................
Brüche............................................................................
80
80
82
83
Inhalt
4.2
4.3
4.4
4.5
Zeichenketten ..............................................................................
86
4.2.1
Eigenschaften..................................................................
86
4.2.2
Operatoren .....................................................................
87
4.2.3
4.2.4
4.2.5
Operationen ...................................................................
Funktionen.....................................................................
Umwandlung von Zeichenkette in Zahl...........................
89
91
94
4.2.6
4.2.7
Listen
Umwandlung von Zahl in Zeichenkette ...........................
Datentyp bytes................................................................
96
97
98
4.3.1
Eigenschaften..................................................................
98
4.3.2
Operatoren..................................................................... 100
4.3.3
Tupel
Funktionen und Operationen .......................................... 101
104
4.4.1
Eigenschaften .................................................................. 104
4.4.2
Operationen...................................................................
4.4.3
Tupel entpacken .............................................................
Dictionarys ..................................................................................
4.5.1
Eigenschaften ..................................................................
4.5.2
4.6
4.8
5
Funktionen ..................................................................... 110
4.5.3
Views .............................................................................. 111
4.5.4 Vergleiche ....................................................................... 113
Mengen, Sets ............................................................................... 114
4.6.1
4.6.2
4.7
104
106
109
109
Eigenschaften .................................................................. 114
Funktionen ..................................................................... 115
4.6.3
Operatoren ..................................................................... 116
4.6.4
Frozenset ........................................................................ 119
Wahrheitswerte und Nichts ......................................................... 120
4.7.1
Wahrheitswerte True und False ....................................... 120
4.7.2
Nichts, None ................................................................... 123
Referenz, Identität und Kopie ...................................................... 125
4.8.1
Referenz und Identität .................................................... 125
4.8.2
Ressourcen sparen .......................................................... 127
4.8.3
Objekte kopieren ............................................................ 128
Weiterführende Programmierung ............................................ 131
5.1
Allgemeines ................................................................................. 131
5.1.1
5.1.2
5.1.3
Kombinierte Zuweisungsoperatoren ................................ 131
Anweisung in mehreren Zeilen ........................................ 133
Eingabe mit Hilfestellung ................................................ 134
7
Inhalt
5.2
5.3
5.4
5.1.4
Anweisung pass .............................................................. 135
5.1.5
Funktionen evalO und execO ........................................... 137
Ausgabe und Formatierung ..........................................................
5.2.1
Funktion printO ...............................................................
5.2.2
Formatierte Ausgabe .......................................................
Conditional Expression ................................................................
138
138
140
144
Iterierbare Objekte ...................................................................... 145
5.4.1
Funktion zipO .................................................................. 146
5.4.2
5.4.3
Funktion mapO ............................................................... 146
Funktion filterO ............................................................... 148
5.5
List Comprehension ..................................................................... 149
5.6
Fehler und Ausnahmen ................................................................ 151
Allgemeines .................................................................... 151
5.6.1
5.7
5.6.2
Syntaxfehler .................................................................... 152
5.6.3
5.6.4
5.6.5
5.6.6
Laufzeitfehler ..................................................................
Logische Fehler und Debugging ......................................
Fehler erzeugen ..............................................................
Unterscheidung von Ausnahmen .....................................
Funktionen .................................................................................. 161
5.7.1
5.8
153
154
158
159
5.7.2
5.7.3
Variable Anzahl von Parametern ...................................... 161
Benannte Parameter ........................................................ 162
Voreinstellung von Parametern ....................................... 163
5.7.4
5.7.5
Mehrere Rückgabewerte ................................................. 164
Übergabe von I<opien und Referenzen ............................ 165
5.7.6
Lokal, global ................................................................... 168
5.7.7
Lambda-Funktion ............................................................ 169
Eingebaute Funktionen ................................................................ 170
5.8.1
Übersicht ........................................................................ 170
5.8.2
Funktionen maxO, minO und sumO ................................. 171
5.8.3
5.8.4
Funktionen chrO und ordO .............................................. 172
Funktionen reversedO und sortedO ................................. 173
5.9
Eigene Module ............................................................................ 174
5.10
5.9.1
Eigene Module erzeugen ................................................. 174
5.9.2
Eigene Module verwenden .............................................. 175
Parameter der I<ommandozeile .................................................... 176
5.10.1 Übergabe von Zeichenketten ........................................... 176
5.10.2 Übergabe von Zahlen ...................................................... 177
5.10.3
8
Beliebige Anzahl von Parametern .................................... 177
Inhalt
6
7
Objektorientierte Program m ieru ng ......................................... 179
6.1
Was ist OOP? .............................................................................. 179
6.2
I<lassen, Objekte und eigene Methoden ....................................... 180
6.3
I<onstruktor und Destruktor ......................................................... 182
6.4
Besondere Methoden .................................................................. 184
6.5
Operatormethoden ...................................................................... 185
6.6
Referenz, Identität und I<opie ...................................................... 187
6.7
Vererbung ................................................................................... 189
6.8
Mehrfachvererbung ..................................................................... 192
Neues in python 3 .................................................................... 195
7.1
7.2
8
Neue und geänderte Eigenschaften .............................................. 195
7.1.1
Auffällige Änderungen ..................................................... 195
7.1.2
Weitere Änderungen ....................................................... 196
I<onvertierung von Python 2 zu Python 3 ..................................... 197
Verschiedene Module ............................................................... 199
8.1
Datum und Zeit ........................................................................... 199
8.1.1
8.1.2
Aktuelle Zeit ausgeben .................................................... 199
8.1.3
Zeitangabe erzeugen ....................................................... 203
8.1.4
Mit Zeitangaben rechnen ................................................ 204
8.1.5
Programm anhalten ......................................................... 206
8.1.6
Spiel, Version mit Zeitmessung ........................................ 208
8.2
Modul collections ........................................................................ 209
8.3
Multithreading ............................................................................ 212
8.3.1
8.4
9
Spielen mit Zeitangabe .................................................... 199
Wozu dient Multithreading? ........................................... 212
8.3.2
Erzeugung eines Threads ................................................. 212
8.3.3
Identifizierung eines Threads ........................................... 213
8.3.4
Gemeinsame Objekte ...................................................... 215
8.3.5
Threads und Exceptions .................................................. 216
Reguläre Ausdrücke ..................................................................... 218
8.4.1
Suchen von Teiltexten ..................................................... 218
8.4.2
Ersetzen von Teiltexten ................................................... 222
Dateien ..................................................................................... 225
9.1
Dateitypen ................................................................................... 225
9.2
Öffnen und Schließen einer Datei ................................................ 226
9
Inhalt
9.3
9.4
Sequenzielle Dateien ................................................................... 227
9.3.1
Sequenzielles Schrei ben .................................................. 227
9.3.2
9.3.3
Sequenzielles Lesen ......................................................... 229
CSV-Datei schreiben ....................................................... 234
9.3.4
CSV- Datei lesen .............................................................. 236
Dateien mit festgelegter Struktur ................................................. 237
9.4.1
9.5
Formatiertes Schreiben .................................................... 238
9.4.2
Lesen an bel iebiger Stelle ................................................ 239
9.4.3
Schreiben an beliebiger Stelle .......................................... 241
Modul pickle ............................................................................... 242
9.5.1
Objekte in Datei schreiben .............................................. 242
9.5.2
Objekte aus Datei lesen .................................................. 244
9.6
Bearbeitung mehrerer Dateien ..................................................... 246
9.7
Informationen über Dateien ......................................................... 247
9.8
Dateien und Verzeichnisse verwalten ........................................... 248
9.9
Spiel, Version mit Highscore-Datei ............................................... 249
9.9.1
Eingabebeispiel ............................................................... 250
9.9.2
Aufbau des Programms ................................................... 250
9.9.3
Code des Programms ...................................................... 251
10 Internet .................................................................................... 257
10.1
10.2
Laden und Senden von Internetdaten .......................................... 257
10.1.1
Lokaler Webserver ....................................................... 257
10.1.2
Daten lesen .................................................................. 258
10.1.3
Daten kopieren ............................................................ 261
10.1.4
Daten senden per GET ................................................. 261
10.1.5
Daten senden per POST ............................................... 264
Webserver-Programmierung ........................................................ 267
10.2.1
10
Erstes Programm .......................................................... 267
10.2.2
Beantworten einer Benutzereingabe ............................. 268
10.2.3
Formularelemente mit mehreren Werten ..................... 272
10.2.4
Typen von Formularelementen ..................................... 274
10.3
Browser aufrufen ......................................................................... 280
10.4
Spiel, Version für das Internet ...................................................... 281
10.4.1
Eingabebeispiel ............................................................ 281
10.4.2
Aufbau des Programms ................................................ 283
10.4.3
Code des Programms ................................................... 284
Inhalt
11 Datenbanken ............................................................................ 291
11.1
Aufbau von Daten banken ............................................................ 291
11.2
SQ Lite ......................................................................................... 292
11.2.1
11.3
Datenbank, Tabelle und Datensätze ............................. 292
11.2.2
Daten anzeigen ............................................................ 295
11.2.3
Daten auswählen, Operatoren ..................................... 296
11.2.4
Operator I ike ............................................................... 298
11.2.5
Sortierung der Ausgabe................................................ 300
11.2.6
Auswahl nach Eingabe ................................................. 301
11.2.7
Datensätze ändern ....................................................... 303
11.2.8
Datensätze läschen ...................................................... 305
SQ Lite auf dem Webserver .......................................................... 306
12 Benutzeroberflächen ................................................................ 309
12.1
12.2
Einführung ................................................................................... 309
12.1.1
Eine erste GUI-Anwendung .......................................... 310
12.1.2
Ändern von Eigenschaften ............................................ 311
Widget-Typen .............................................................................. 313
12.2.1
12.3
Anzeigefeld, Label ........................................................ 313
12.2.2
Einzeilige Textbox, Entry .............................................. 316
12.2.3
Versteckte Eingabe ...................................................... 318
12.2.4
Mehrzeilige Textbox, Text ............................................ 320
12.2.5
Scrollende Textbox, ScrolledText .................................. 322
12.2.6
Listbox mit einfacher Auswahl ...................................... 323
12.2.7
Listbox mit mehrfacher Auswahl .................................. 325
12.2.8
Scrollbar, scrollende Widgets ....................................... 327
12.2.9
Radio-Buttons zur Auswahl, Widget-Variablen ............. 329
12.2.10
12.2.11
Radio-Buttons zur Auswahl und Ausführung ................ 331
Check-Buttons zur mehrfachen Auswahl ...................... 333
12.2.12
Schieberegler, Scale ..................................................... 335
12.2.13
Mausereignisse ............................................................ 338
12.2.14
Tastaturereignisse ........................................................ 341
Geometrische Anordnung von Widgets ........................................ 343
12.3.1
Frame-Widget, Methode packO ................................... 343
12.3.2
Ein einfacher Taschenrechner ....................................... 346
12.3.3
Methode gridO ............................................................ 351
12.3.4
Methode placeO, absolute Koordinaten ....................... 353
11
Inhalt
12.4
12.3.5
Methode placeO, relative I<oord inaten ......................... 355
12.3.6
Absolute Veränderung von I<oordinaten ...................... 357
12.3.7
Relative Veränderung von I<oord inaten ........................ 359
Menüs und MessageBoxes ........................................................... 363
12.4.1
Menüleisten ................................................................. 363
12.4.2
I<ontextmenüs ............................................................. 368
12.4.3
Message Boxes.............................................................. 372
13 Lösungen .................................................................................. 379
Index ............................................................................................................ 387
12
I
1
Einführung
In diesem Kapitel wird Ihnen Python kurz vorgestellt. Sie lernen die Vorteile von Python kennen und erfahren, wie die Programmierumgebung
unter Windows installiert wird.
1.1
Vorteile von Python
Python ist eine sehr einfach zu erlernende Programmiersprache und für
den Einstieg in die Welt der Programmierung ideal geeignet. Trotz ihrer
Einfachheit bietet diese Sprache auch die Möglichkeit, komplexe Programme für vielfältige Anwendungsgebiete zu schreiben.
Leicht zu lernen
Python eignet sich besonders zur schnellen Entwicklung umfangreicher
Anwendungen. Diese Technik ist unter dem Stichwort RAD (= Rapid
Application Development) bekannt geworden. Python vereint zu diesem
Zweck folgende Vorteile:
~
Eine einfache, eindeutige Syntax: Python ist eine ideale Programmiersprache für Einsteiger. Sie beschränkt sich auf einfache, klare Anweisungen. In anderen Programmiersprachen werden vielfältige Lösungswege für das gleiche Problem angeboten, sodass der Entwickler
weniger geleitet als verunsichert wird. Python beschränkt sich dagegen
häufig auf einen einzigen möglichen Lösungsweg. Dieser prägt sich
schnell ein und wird dem Entwickler vertraut.
Einfach
~
Klare Strukturen: Python zwingt den Entwickler, in einer gut lesbaren
Struktur zu schreiben. Die Anordnung der Programmzeilen ergibt
gleichzeitig die logische Struktur des Programms.
Klar
~
Wiederverwendung von Code: Die Modularisierung, also die Zerlegung eines Problems in Teilprobleme und die anschließende Zusammenführung der Teillösungen zu einer Gesamtlösung, wird in Python
sehr leicht gemacht. Die vorhandenen Teillösungen können unkompliziert für weitere Aufgabenstellungen genutzt werden, sodass Sie als
Entwickler bald über einen umfangreichen Pool an Modulen verfügen.
Wiederverwendbar
13
1
I
Einführung
Einheitliche
Objekte
~
Objektbearbeitung: In Python werden alle Daten als Objekte gespeichert. Dies führt zu einer einheitlichen Datenbehandlung für Objekte
unterschiedlichen Typs. Andererseits wird die physikalische Speicherung der Objekte von Python automatisch, ohne Eingriff des Entwicklers vorgenommen. Der Entwickler muss sich nicht um die Reservierung und Freigabe geeigneter Speicherbereiche kümmern.
Interpretiert
~
Interpreter / Compiler: Python-Programme werden unmittelbar interpretiert. Sie müssen nicht erst kompiliert und gebunden werden. Dies
ermöglicht einen häufigen, schnellen Wechsel zwischen Codierungsund Testphase.
Unabhängig
~
Unabhängigkeit vom Betriebssystem: Sowohl Programme, die von
der Kommandozeile aus bedient werden, als auch Programme mit
grafischen Benutzeroberflächen können auf unterschiedlichen
Betriebssystemen (Windows, Unix/Linux, Mac OS) ohne Neuentwicklung und Anpassung eingesetzt werden.
1.2
Verbreitung von Python
Innerhalb des Projekts 100-Dollar-Laptop, das der Schulausbildung von
Kindern in aller Welt dient, wird Python für die Benutzeroberfläche verwendet. Es wird in zahlreichen weiteren Unternehmen eingesetzt:
~
Google: Python ist eine der drei offiziellen Programmiersprachen.
(Guido van Rossum, der Entwickler von Python, arbeitet für Google.)
~
YouTube: Wurde zum großen Teil mit Hilfe von Python entwickelt.
~
NASA: Nutzt Python zur Softwareentwicklung im Zusammenhang mit
den Space-Shuttle-Missionen.
~
Industrial Light and Magic (Filmproduktion)
~
Honeywell (Hardware- und Softwareentwicklung)
1.3
Aktiv lernen
Aufbau des Buchs
Das vorliegende Buch soll Sie in die Programmiersprache Python einführen. Es wird besonderer Wert darauf gelegt, dass Sie selbst praktisch mit
Python arbeiten. Daher möchte ich Sie von Anfang an dazu auffordern,
dem logischen Faden von Erklärungen und Beispielen zu folgen.
Erste Zusammenhänge werden in Kapitel 2, »Erste Schritte«, anhand von
einfachen Berechnungen vermittelt. Außerdem lernen Sie, ein Pro-
14
Übungen
I
1·4
gramm einzugeben, zu speichern und es unter den verschiedenen Umgebungen auszuführen.
Sie sollen die Sprache spielerisch kennenlernen. Daher wird Sie ein selbst
programmiertes Spiel durch das Buch begleiten. Dieses Spiel wird mit dem
»Programmierkurs« in Kapitel 3 eingeführt und im weiteren verlauf des
Buchs kontinuierlich erweitert und verbessert.
Spielerisch lernen
Nach der Vorstellung der verschiedenen Datentypen mit ihren jeweiligen Eigenschaften und Vorteilen in Kapitel 4, »Datentypen«, werden die
Programmierkenntnisse in Kapitel 5, »Weiterführende Programmierung«, vertieft.
Kapitel 6, »Objektorientierte Programmierung«, widmet sich der objektorientierten Programmierung mit Python.
Objektorientiert
Python hat mit der Version 3.0 große Änderungen erfahren. Diese Änderungen sind in alle Kapitel und Programme dieses Buchs integriert. Kapitel 7, »Neues in Python 3«, fasst die Neuerungen, die besonders für Einsteiger interessant sind, noch einmal übersichtlich zusammen.
Python 3.0
Einige nützliche Module zur Ergänzung der Programme werden im Kapitel 8, »Verschiedene Module«, vorgestellt.
In den Kapiteln 9, »Dateien«, und 11, »Datenbanken«, lernen Sie, Daten
dauerhaft in Dateien oder Datenbanken zu speichern. Python wird
zudem in der Internetprogrammierung eingesetzt. Die Zusammenhänge
zwischen Python und dem Internet vermittelt Kapitel 10, »Internet«.
Sowohl Windows als auch Linux bieten komfortable grafische Benutzeroberflächen. Kapitel 12, »Benutzeroberflächen«, beschäftigt sich daher mit
der Erzeugung von Benutzeroberflächen mithilfe des Moduls tkinter.
Dieses stellt eine Schnittstelle zwischen dem grafischen Toolkit Tk und
Python dar.
Für die Hilfe bei der Erstellung dieses Buchs bedanke ich mich bei Bettina
Mosbach, Carsten Reimer und dem ganzen Team von Galileo Press, ganz
besonders bei Christine Siedle.
1.4
Übungen
In Kapitel 3, »Programmierkurs«, und in weiteren Kapiteln werden
Übungsaufgaben gestellt, die unmittelbar gelöst werden sollten. Auf
diese Weise können Sie Ihre Kenntnisse prüfen, bevor Sie zum nächsten
15
Grafische
Oberflächen
I