Martin Vogel - Grundlagen Der Informatik - Python 3 WS2013-14

Hochschule Bochum WS 2013/2014

Grundlagen der Ingenieurinformatik mit Python 3 Dipl.-Ing. Martin Vogel

Inhaltsverzeichnis 1. Einleitung.....................................................................................6 1.1. Bedeutung der Ingenieurinformatik.................................................6 1.2. Aufbau des Kurses............................................................................7 1.3. Warnung............................................................................................7 2. Grundwissen.................................................................................9 2.1. Betriebssystem.................................................................................9 2.2. Dateien..............................................................................................9 2.3. Verzeichnisbäume...........................................................................10 2.4. Windows’ unvollständige Dateinamen............................................10 2.4.1. Die Mode der falschen Verzeichnisnamen...............................12 2.5. Archivdateien..................................................................................14 2.6. Zwischenablage..............................................................................15 2.6.1. Bildschirmkopien.....................................................................16 2.6.2. Sonderzeichen..........................................................................16 2.7. Texteditor........................................................................................18 2.8. Textverarbeitung.............................................................................20 2.9. Tabellenkalkulation.........................................................................21 2.9.1. Formeln....................................................................................22 2.9.2. Zellbereiche.............................................................................22 2.9.3. Fallunterscheidungen..............................................................24 2.9.4. Diagramme...............................................................................25 2.9.5. CSV-Dateien.............................................................................25 2.10. VPN – das virtuelle private Netzwerk...........................................26 3. Hypertext....................................................................................27 3.1. Tags.................................................................................................28 3.2. Hierarchische Ordnung..................................................................28 3.3. Attribute..........................................................................................30 3.4. HTML-Entitys..................................................................................31 3.5. CSS.................................................................................................31 4. Algorithmen und ihre Darstellung.............................................32 4.1. Flussdiagramme.............................................................................32 4.2. Struktogramme...............................................................................33 4.2.1. Sequenzen................................................................................33 4.2.2. Fallunterscheidungen..............................................................33 4.2.3. Mehrfachauswahl.....................................................................34 4.2.4. Abweisende Schleife................................................................34 Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

1

4.2.5. 4.2.6. 4.2.7. 4.2.8.

Nichtabweisende Schleife........................................................35 Endlosschleife..........................................................................35 Endlosschleife mit Aussprung..................................................36 Beispiel für ein vollständiges Struktogramm..........................36

5. Python........................................................................................ 38 5.1. Download und Installation..............................................................39 5.2. Erste Schritte in der Python-Shell von IDLE..................................39 5.3. Fehlermeldungen............................................................................41 5.4. Variablen.........................................................................................42 5.4.1. Variablennamen.......................................................................43 5.5. Eingabe mit input().........................................................................44 5.6. Ausgabe mit print().........................................................................45 5.6.1. Alternatives Trennzeichen.......................................................45 5.6.2. Alternatives Zeilenende...........................................................46 5.7. Einfache Datentypen......................................................................46 5.8. Typumwandlung.............................................................................47 5.8.1. Evaluation von Ausdrücken.....................................................48 5.9. Das erste richtige Programm.........................................................49 5.10. Kommentare.................................................................................50 5.10.1. Shebang und Zeichenkodierung............................................51 5.11. Rechenoperationen.......................................................................52 5.11.1. Verkürzte Arithmetiknotation................................................53 5.12. Mathematische Funktionen: das Modul math..............................53 5.13. Verzweigungen.............................................................................54 5.14. Logische Aussagen.......................................................................55 5.14.1. Vergleichsoperatoren.............................................................55 5.14.2. Logische Aussagen über Gleitkommazahlen.........................55 5.15. Boolesche Algebra........................................................................57 5.15.1. Die Konjunktion: and..............................................................58 5.15.2. Die Disjunktion: or.................................................................58 5.15.3. Die Negation: not...................................................................58 5.15.4. Die Kontravalenz: ^...............................................................59 5.15.5. Prioritäten..............................................................................59 5.15.6. Umkehrung logischer Aussagen............................................59 5.15.7. Boolesche Variablen...............................................................60 5.16. Venn-Diagramme..........................................................................60 5.17. Fallunterscheidungen: if … elif …else..........................................62 5.18. Fehlerbehandlung.........................................................................65

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

2

5.19. Programmschleifen.......................................................................67 5.19.1. Bedingte Schleifen: while......................................................67 5.19.2. Aussprung mit break..............................................................69 5.19.3. Iterative Schleifen: for...........................................................72 5.19.4. Der Iterator range()...............................................................72 5.19.5. Verschachtelte Schleifen........................................................73 5.20. Listen............................................................................................75 5.20.1. Tupel......................................................................................75 5.20.2. Listenidizes............................................................................75 5.20.3. Listenabschnitte (Slices)........................................................76 5.20.4. Kopieren einer Liste...............................................................76 5.20.5. Umwandlung eines Iterators in eine Liste.............................77 5.20.6. Listenerzeugung (List Comprehension).................................77 5.20.7. Listenelemente als Einzelparameter.....................................78 5.20.8. Funktionen für Tupel und Listen...........................................79 5.20.9. Methoden von Listen.............................................................79 5.21. Vektoren........................................................................................80 5.21.1. Vektoraddition........................................................................81 5.21.2. Skalarprodukt........................................................................82 5.21.3. Formatierte Ausgabe eines Vektors.......................................82 5.22. Matrizen........................................................................................83 5.22.1. Nullmatrix..............................................................................84 5.22.2. Einheitsmatrix........................................................................84 5.22.3. Größe einer Matrix ermitteln.................................................85 5.22.4. Matrizen kopieren..................................................................85 5.22.5. Matrizen transponieren.........................................................86 5.22.6. Matrizen addieren..................................................................86 5.22.7. Matrizen multiplizieren..........................................................88 5.22.8. Matrix mit Vektor multiplizieren............................................90 5.22.9. Matrix invertieren..................................................................91 5.22.10. Anwendungsbeispiel: Gleichungslöser................................92 5.23. Eigene Funktionen definieren......................................................94 5.23.1. Eingangswerte (Argumente)..................................................95 5.23.2. Vorbelegte Eingangswerte.....................................................95 5.23.3. Beliebig viele Eingangswerte.................................................96 5.24. Sichtbarkeit von Variablen...........................................................96 5.25. Eigene Module..............................................................................97 5.25.1. Modulpfade............................................................................98 5.25.2. Funktionsweiser Import.........................................................99 5.25.3. Modulweiser Import.............................................................100

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

3

5.25.4. Funktionsüberschreibungen................................................100 5.25.5. Funktionszuweisungen........................................................102 5.26. Zeichenketten.............................................................................102 5.26.1. Anführungszeichen in Zeichenketten..................................102 5.26.2. Mehrzeilige Ausgabe............................................................103 5.26.3. Formatierung mit Platzhaltern............................................103 5.26.4. printf-kompatible Formatierung..........................................104 5.26.5. Die Methode .format()..........................................................105 5.26.6. Kodierung und Dekodierung................................................105 5.27. Dateiverarbeitung.......................................................................106 5.27.1. Öffnen und Schließen von Dateien......................................106 5.27.2. Lesen und Schreiben von Dateien.......................................107 5.28. Grafik..........................................................................................107 5.28.1. Das Hauptfenster.................................................................107 5.28.2. Canvas – die Leinwand.........................................................109 5.28.3. Koordinaten der Canvas.......................................................111 5.28.4. Koordinatentransformationen..............................................111 5.28.5. Linien und Linienzüge..........................................................112 5.28.6. Pfeilspitzen...........................................................................114 5.28.7. Gestrichelte Linien...............................................................114 5.28.8. Splines (Kurvenlinien)..........................................................115 5.28.9. Geschlossene Polygone........................................................116 5.28.10. Rechtecke und Ellipsen......................................................117 5.28.11. Kreise.................................................................................117 5.28.12. Text.....................................................................................118 5.28.13. GUI – Grafische Benutzeroberflächen...............................119 5.28.14. Anordnung der GUI-Elemente...........................................120 6. Datenspeicherung und Zahlensysteme....................................121 6.1. Bits und Bytes...............................................................................121 6.1.1. Das Bit....................................................................................121 6.1.2. Das Byte.................................................................................122 6.1.3. Das Hexadezimalsystem........................................................123 6.2. Zeichenkodierung.........................................................................124 7. Anhang..................................................................................... 126 7.1. Häufige Fehlermeldungen............................................................126 7.2. Farben und Farbnamen (Auswahl)...............................................127 7.3. Abbildungsverzeichnis..................................................................131 7.4. Links und Literaturhinweise.........................................................134 7.5. Lizenz............................................................................................135

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

4

7.6. Download und Feedback...............................................................136

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

5

1. Einleitung Dieses Buch ist eine Ergänzung zur seit 2009 von mir gehaltenen Vorlesung „Grundlagen der Ingenieurinformatik“ im Fachbereich Bauingenieurwesen der Hochschule Bochum. Hierin finden Sie außer vielen Inhalten der Vorlesungen auch einige Zusatzinformationen, die in ihrer Breite nicht in Hörsaal-Lehrveranstaltungen passen. In den Vorlesungen und Übungen lernen wir wichtige Konzepte der Informatik kennen, indem wir uns selbst sprachliche Werkzeuge schaffen, mit denen wir ingenieurmäßige Probleme lösen werden. Wir bauen diese Werkzeuge, indem wir Handlungsanweisungen in einer Sprache formulieren, die ein Computer interpretieren und ausführen kann – einer Programmiersprache. Das vorliegende Werk ist kein Vorlesungsskript im klassischen Sinne. Die Reihenfolge der Kapitel im Buch ist nicht dieselbe wie in der Vorlesung, da ich diesen Text zum leichteren Nachschlagen nach Sachthemen gegliedert habe. Außerdem müssen wir in der Vorlesung für die Praktika und Übungen manche Techniken gelegentlich schon kurz kennenlernen, die erst später ausführlich behandelt werden. Diese Vorgriffe tauchen im Buch nicht auf. Der Text ist nicht als eigenständiges Selbstlernbuch konzipiert und stellt kein umfassendes Kompendium zur Programmiersprache Python dar. Wer das Buch trotzdem dazu einsetzt, um ohne die dazugehörende Vorlesung Python zu lernen, kann mir bitte schreiben, wenn es dennoch funktioniert. Meine Adresse steht auf der letzten Seite.

1.1.

Bedeutung der Ingenieurinformatik

Die Anwendung von Computern, ob in stationärer oder mobiler Form, ist eine Kulturtechnik geworden, in die man mehr oder weniger von Kindheit an hineinwächst. Als Ingenieurinnen und Ingenieure stehen wir aber vor der Aufgabe, Computer nicht nur nach Anleitung zu bedienen, sondern sie auch als individuelles Werkzeug zur Lösung von gerade nicht standardisierten Problemen einzusetzen. Die Grenzen populärer Bürosoftware sind mitunter schneller erreicht als es uns lieb ist und oft können wir scheinbar komplexe Probleme mit wenigen Zeilen Programmcode elegant und schnell lösen, die mit Ausdauer, Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

6

Fleiß und Überstunden zwar auch bewältigt werden können, dann aber deutlich weniger zur Arbeitsfreude beitragen. Viele scheinbar absurde Phänomene bei der Anwendung von Standardsoftware lassen sich zudem erst dann verstehen, wenn wir wissen, was „unter der Motorhaube“ geschieht. Informatik ist weit mehr als nur Programmierung, aber das Schreiben von Computerprogrammen wird in diesem Kurs der rote Faden sein, der sich durch die Exkurse in die Welt der formalen Sprachen, der Aussagenlogik und der Algorithmen zieht.

1.2.

Aufbau des Kurses

Der Kurs gliedert sich in 15 zweistündige Vorlesungen im Hörsaal, in denen der neue Stoff vorgestellt wird und mehrere Übungen in kleineren Gruppen, in denen das Gelernte praktisch angewendet wird. Im Mittel sind dazu ebenfalls zwei Wochenstunden anzusetzen. Der wöchentliche Arbeitsaufwand umfasst zudem sechs Stunden eigenverantwortlichen Lernens, das bei den meisten in Kleingruppen mit drei bis fünf Personen am effektivsten ist. Es ist keine gute Idee, diese neunzig Stunden komplett in die Woche vor der Klausur zu schieben. Sie haben viel mehr Spaß am Fach, wenn Sie die Vorlesungsinhalte so zeitnah wie möglich und so intensiv wie möglich nacharbeiten.

1.3.

Warnung

Dieses Buch ersetzt keine eigene Vorlesungsmitschrift. Damit Sie wirklich etwas lernen, benötigen Sie außer Ihren Augen auch Ihre Hände. Schreiben Sie mit, machen Sie sich Notizen – vor allem, wenn etwas unklar ist. Besprechen Sie offen gebliebene Fragen nach der Vorlesung mit ihrer Lerngruppe, suchen Sie die Antworten in diesem Text, im Internet oder in der Literatur. Sie lernen nicht, zu programmieren, indem Sie dieses Buch ein paar Mal durchlesen. Sie lernen es vor allem, indem Sie eigenhändig Programme schreiben, Fehler machen (das ist wirklich wichtig!), Fehlermeldungen verstehen und Fehlerursachen finden, begreifen und beseitigen. Immer wieder. Bearbeiten Sie vor allem die Übungsaufgaben selbst und besorgen Sie sich keine fertigen Lösungen. Sie machen die Übungen nicht, um zur ErMartin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

7

füllung formaler Rahmenbedingungen ein Werk abzuliefern, sondern um bei der eigenen Arbeit daran die Lehrinhalte zu vertiefen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

8

2. Grundwissen In den Vorlesungen und Übungen des Kurses „Grundlagen der Ingenieurinformatik“ setze ich gewisse allgemeine Computergrundkenntnisse voraus. In diesem Kapitel erhalten Sie einen kurzen Überblick über einige Begriffe und Techniken, die sie verstanden haben sollten, bevor Sie sich mit den eigentlichen Themen dieses Semesters auseinandersetzen.

2.1.

Betriebssystem

Als Betriebssystem bezeichnet man eine Programmsammlung, die Anwendungsprogrammen standardisierte Werkzeuge zum Zugriff auf interne und externe Geräte, gespeicherte Daten und Datenträger sowie die Kommunikationskanäle eines Rechnersystems zur Verfügung stellt. Das auf Desktop-PCs und Notebooks im Ingenieurbereich hierzulande derzeit verbreiteteste Betriebssystem ist Microsoft Windows, gefolgt von Linux und Mac OS. Auf mobilen Kleingeräten wie Smartphones und Tablets sorgen in der Mehrzahl die Betriebssysteme Android und iOS für die Kommunikation zwischen den dort Apps genannten Programmen und der Gerätetechnik.

2.2.

Dateien

Eine Datei ist eine Gruppe von Informationen, die in einem Verzeichnis eines Dateisystems durch einen eindeutigen Dateinamen identifizierbar ist. Abhängig von ihrem Inhalt unterscheidet man oft zwischen Grafikdateien, Textdateien, Programmdateien und anderen Dateitypen. Die englischsprachige Bezeichnung für Datei lautet file (Akte). Im Zusammenhang mit Dateien ist oft die Rede davon, dass diese „geöffnet“ oder „geschlossen“ werden. Die Anmeldung eines Programms beim Betriebssystem zum Zugriff auf eine Datei nennt man „Öffnen“. Greift ein Programm nicht mehr auf eine Datei zu, meldet es seine Zugriffserlaubnis wieder ab. Die Datei wird „geschlossen“. Unter Microsoft Windows können Dateien häufig nur von einem einzigen Programm gleichzeitig bearbeitet werden. Bevor man sie mit einem anderen Programm „öffnen“ kann, muss das erste Programm sie „schließen“.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

9

2.3.

Verzeichnisbäume

Dateien werden üblicherweise in einer hierarchischen, baumähnlichen Verzeichnisstruktur abgelegt. Jedes Verzeichnis kann außer Dateien auch wieder andere Verzeichnisse enthalten, diese heißen Unterverzeichnisse. Im botanischen Gegenstück entsprechen die Dateien den Blättern und die Verzeichnisse den Ästen und Zweigen. Kurioserweise wird die Wurzel (oder der „Stamm“) eines Verzeichnisbaums meistens als obenliegend angesehen, was ihn klar von seinen botanischen Verwandten unterscheidet.

Abb. 1: Teil des Verzeichnisbaums unter Windows 7

2.4.

Windows’ unvollständige Dateinamen

Für Programme, die Dateien verarbeiten, ist es erforderlich, den genauen Namen einer Datei und des Verzeichnisses, in dem diese sich befindet, zu kennen. Leider wird beides im Windows-Explorer in der Regel nicht oder sogar falsch angezeigt. Dateien verfügen seit den Anfängen des Personalcomputers über ein Kürzel am Ende des Dateinamens, das Windows zur Bestimmung des Dateityps verwendet. Dieses Kürzel, die sogenannte Dateinamenerweiterung oder Extension, beginnt mit einem Punkt und ist in der Regel zwei bis vier Buchstaben lang. Unter anderen Betriebssystemen wie Mac OS X oder Linux gibt es diesen Zwang zur Dateinamenerweiterung nicht. Um diese Benutzerfreundlichkeit zu simulieren, versteckt der Windows-Explorer daher seit Windows XP die Dateinamenerweiterungen vor dem Benutzer. Das hat den unangenehmen Nebeneffekt, dass Dateien nicht mehr vollständig umbenannt werden können. Eine neu angelegte Textdatei „BeMartin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

10

rechnung.txt“ wird im Windows-Explorer beispielsweise nur als „Berechnung“ angezeigt. Handelt es sich bei der Textdatei aber um ein PythonProgramm, so sollte es stattdessen auf „.py” enden, um durch Doppelklick gestartet oder mittels Rechtsklick mit IDLE geöffnet zu werden. Man kann zwar versuchen, die Datei umzubenennen – der WindowsExplorer zeigt die umbenannte Textdatei anschließend auch als „Berechnung.py“ an, führt das darin enthaltene Programm jedoch beim Doppelklicken nicht aus, sondern lädt die Datei nur in den Texteditor. In Wirklichkeit heißt sie nun nämlich „Berechnung.py.txt“ und wird von Windows immer noch als Textdatei behandelt. Um dieses Problem zu beseitigen, ist im Windows-Explorer eine Einstellung vorzunehmen, die dafür sorgt, dass Dateinamen grundsätzlich unverstümmelt angezeigt werden. In Microsoft Windows XP muss dazu unter „Extras – Ordneroptionen – Ansicht – Erweiterte Einstellungen“ das Häkchen vor „Erweiterungen bei bekannten Dateitypen ausblenden“ entfernt werden. Im Windows-Explorer von Microsoft Windows 7 ist dasselbe Menü unter „Organisieren – Ordner- und Suchoptionen – Ansicht – Erweiterte Einstellungen“ zu finden.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

11

Abb. 2: Ordneroptionen in Windows XP

2.4.1.

Die Mode der falschen Verzeichnisnamen

Unter Windows, aber auch unter nahezu allen anderen modernen Betriebssystemen gibt es das Konzept einer Arbeitsfläche (Desktop), auf der Dateien und Verzeichnisse zum schnellen Zugriff abgelegt werden können. Im Windows-Explorer von Microsoft Windows XP wird der Verzeichnisbaum auf der linken Seite sogar so dargestellt, als sei der Desktop die oberste Instanz in der Ordnungshierarchie eines Computers. Das wurde später zugunsten eines anderen Ordnungsschemas verworfen. In Microsoft Windows 7 findet man zuoberst die von Microsoft so genannten „Favoriten“, zum Beispiel die Arbeitsfläche „Desktop“ und den Ordner „Downloads“ für heruntergeladene Dateien. Unter den Favoriten sind die „Bibliotheken“, das sind die persönlichen Ordner für Bilder, „Dokumente“, Musik und Videos, zu finden. Klein und versteckt tauchen irgendwo weit unten unter „Computer“ doch noch die Laufwerke auf.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

12

Abb. 3: Bibliotheken im Windows-Explorer

Die tatsächliche Verzeichnisstruktur ist unter Microsoft Windows fast genau entgegengesetzt. Oberste Ordnungsinstanz sind hier die Laufwerke, denen feste Buchstaben zugeordnet werden (die Festplatte heißt fast immer „C:\“). Darunter sind Verzeichnisse für das Betriebssystem („C:\Windows“), für Programme (seit Microsoft Windows Vista „C:\Program Files“, vorher „C:\Programme“) und für die Benutzer (seit Microsoft Windows Vista jeweils „C:\Users\Benutzername“, davor – seit Windows 2000 – „C:\Dokumente und Einstellungen\Benutzername“ und in noch älteren Windowsversionen seit Microsoft Windows 95 „C:\Windows\Profiles\Benutzername“). Der Desktop findet sich in Microsoft Windows 7 schließlich tief unten als „C:\Users\Benutzername\Desktop“ und die eigenen Dateien auf derselben Ebene als „C:\Users\Benutzername\Documents“.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

13

Abb. 4: Eigene Dateien unter Windows 7

Das Verzeichnis „C:\Users“ entspricht damit unter Windows 7 dem Verzeichnis „/home“ anderer Betriebssysteme wie Linux oder Unix oder dem Verzeichnis „/Users“ unter Mac OS X. Der Windows-Explorer zeigt die wahren Verzeichnisnamen an, wenn man in der ganz oben im Fenster angezeigten Adressleiste auf das Icon links des Verzeichnisnamens klickt. Aus dem vorgetäuschten Namen „«Benutzer‣Benutzername‣Eigene Dokumente“ wird dann der echte Name „C:\Users\Benutzername\Documents“. Wir benötigen diese wahren Datei- und Verzeichnisnamen, wenn wir in Kapitel 5.26 beginnen, Python-Programme zu schreiben, die selber Dateien anlegen, lesen, verarbeiten und schreiben werden. Bis dahin genügen uns der Desktop oder der Dokumentenordner der „Bibliotheken“.

2.5.

Archivdateien

Um Gruppen von Dateien einfacher weitergeben zu können und um Platz zu sparen, lassen sich mehrere Dateien zu einer Archivdatei zusammenfassen. Unter Microsoft Windows heißen diese Archivdateien „ZIP-komprimierte Ordner“. Die Funktion zum Anlegen eines ZIP-Archives ist etwas versteckt angeordnet und befindet sich beim Windows-Explorer im Kontextmenü der rechten Maustaste unter dem Menüpunkt „Senden an …“.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

14

Abb. 5: Anlegen eines ZIP-Archives über das Kontextmenü des Windows-Explorers

2.6.

Zwischenablage

Die Zwischenablage (ZA) ist unter vielen Betriebssystemen ein Konzept, mit dem innerhalb eines Programms oder programmübergreifend Daten ausgetauscht werden können. Meistens ist die Zwischenablage über das Menü „Bearbeiten“ erreichbar, fast immer (leider ausgerechnet nicht in IDLE) über die rechte Maustaste und am schnellsten über drei Steuerungstastenkombinationen: •

Strg-C

Kopieren (Markierte Inhalte werden in die ZA kopiert)

•

Strg-X

Ausschneiden (Inhalte werden in die ZA verschoben)

•

Strg-V

Einfügen (Von der Zwischenablage an ein neues Ziel)

Gelegentlich gibt es auch noch die Funktion „Einfügen als …“, die es erlaubt, das Format oder die Art der einzufügenden Daten auszuwählen (zum Beispiel „normaler Text“ oder „formatierter Text“). Sie ist in einigen Programmen direkt über die Tastenkombination Strg-⇧-V erreichbar. Bei manchen Rechnern ist die Steuerungstaste nicht mit „Strg“ (Steuerung), sondern mit „Ctrl“ (Control) beschriftet. Auf Apple-Rechnern werden die Tastaturkommandos für die Zwischenablage nicht mit der Steuerungstaste, sondern mit der Taste „⌘“ (Command) ausgelöst.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

15

2.6.1.

Bildschirmkopien

Zu Dokumentationszwecken ist es oft sinnvoll, Grafiken mit dem aktuellen Bildschirminhalt in einen Text einzufügen. Als sehr praktisch erweist sich dazu die Taste „Druck“. Diese kopiert unter den meisten Windowsund Linuxversionen den gesamten Bildschirminhalt in die Zwischenablage oder schreibt ihn gleich in eine Bilddatei. Die Tastenkombination „AltDruck“ kopiert nur den Inhalt des aktuellen Fensters (einschließlich der Fensterdekorationen wie Rahmen und Titelzeile). Die meisten Bildschirmkopien1 in diesem Buch sind so entstanden. Auf Apple-Tastaturen gibt es keine Druck-Taste, hier helfen die Tastenkombinationen ⌘-control-⇧-3 und ⌘-control-⇧-4 weiter. Selbst Mobiltelefone verfügen gelegentlich über eine Screenshotfunktion. Unter Android 4 wird diese beispielsweise durch exakt gleichzeitiges Drücken der Tasten „an/aus“ und „leiser“ ausgelöst.

2.6.2.

Sonderzeichen

Buchstaben, Symbole und andere Zeichen, die nicht über einzelne Tastendrücke eingegeben werden können, nennen wird Sonderzeichen. Die meisten modernen Programme unterstützen die international genormte Zeichenzusammenstellung Unicode. Jedes weltweit verwendete Schriftzeichen und tausende gängige Symbole sind dort mit einer festgelegten Kodierung zu finden. So lauten die Zeichencodes für die beiden griechischen Buchstaben α und β beispielsweise U+03b1 und U+03b2. Um Sonderzeichen in Python zu verwenden, können wir entweder diesen Zeichencode

verwenden,

wir

schreiben

„α

und

β“

dann

als

print("\u03b1 und \u03b2"), oder wir können das jeweilige Zeichen aus der Zeichentabelle des Betriebssystems heraussuchen und über die Zwischenablage in den Quelltext einfügen. Unter Microsoft Windows sollten Sonderzeichen wie α und β, die nicht auf der Tastatur zu finden sind, mit großer Vorsicht eingesetzt werden. Wenn das Python-Programm auch in der Windows-Konsole 2 laufen soll (damit es zum Beispiel einfach mittels Doppelklick im Windows-Explorer gestartet werden kann), sollte es möglichst gar keine Sonderzeichen ver1 Bildschirmkopien werden auch „Screenshots“ genannt. 2 Das schwarze Fenster mit dem weißen Text wird auch „Kommandozeile“, „MS-DOSShell“ oder „Eingabeaufforderung“ genannt.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

16

Abb. 6: Die Zeichentabelle von Windows 8

wenden, da die meisten Unicodezeichen dort nicht angezeigt werden können und der Versuch zu einer Fehlermeldung mit Programmabbruch führt.

Abb. 7: Die tückische alte DOS-Shell

Solange unsere Python-Programme nur innerhalb von IDLE oder in moderneren Betriebssystemen laufen, ist die Verwendung von Unicodezeichen unkritisch und sorgt für eine deutlich verbesserte MenschMaschine-Kommunikation.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

17

2.7.

Texteditor

Wir brauchen zum Editieren, also zum Verfassen und Bearbeiten von Quelltexten ein geeignetes Programm. Python bietet mit der integrierten Entwicklungsumgebung „IDLE“ bereits einen einfachen Texteditor an. Dieser ist für kleinere Programme recht praktisch – nicht zuletzt, weil durch simples Drücken der Taste F5 sofort das gerade getippte Programm ausgeführt werden kann. Es schadet jedoch nicht, ein komfortableres Programm zu verwenden. Ein

Textverarbeitungsprogramm

wie

Microsoft

Office

Word

oder

LibreOffice Writer ist dazu ungeeignet, da beim Speichern in den Stan1

darddateiformaten dieser Programme zusätzliche Metadaten, beispielsweise Gestaltungs- und Verwaltungsinformationen, in die Dateien geschrieben werden, wodurch die eigentlichen Inhalte für unsere Zwecke unbrauchbar werden. Besser ist es, spezielle Texteditoren „für Programmierer” zu verwenden. Diese besitzen oft eine besondere Hilfe für Autoren, indem sie die verschiedenen Elemente eines Quelltextes auf dem Monitor farblich hervorheben. Diese sogenannte Syntaxhervorhebung (engl.: syntax highlighting) ist bei der Fehlersuche hilfreich, da falsch geschriebene Schlüsselwörter oder fehlende Klammern und Anführungszeichen gleich zu einer farblichen Auffälligkeit der Fehlerstelle führen. In Linux-Distributionen wie Ubuntu Linux sind in der Regel eine Vielzahl geeigneter Editoren enthalten. Populäre Editoren mit grafischer Benutzeroberfläche sind beispielsweise „gedit“ oder „geany“. Welchen Texteditor Sie zum Verfassen und Bearbeiten von Quelltexten verwenden, ist weitgehend Geschmackssache.

1 Das ist das Programm, mit dem dieses kostenlose Python-Lehrbuch verfasst wurde: http://de.libreoffice.org.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

18

Abb. 8: Gedit unter Ubuntu Linux

Wichtig ist neben der Syntaxhervorhebung vor allem, dass der Editor die Nummer der aktuellen Textzeile anzeigt, damit Sie diese bei Fehlern im Quelltext schnell auffinden können. Damit das Syntax-Highlighting funktioniert, muss der Editor „wissen“, welche Art von Text Sie schreiben. Ein Python-Programm wird anders farbig markiert als ein HTML-Quelltext. In der Regel wird die Entscheidung anhand der Dateinamenerweiterung getroffen. Solange ein neuer Text nicht gespeichert ist, ist das Syntax-Highlighting daher in der Regel inaktiv. Unter Microsoft Windows gibt es in der Standardausstattung des Betriebssystems keine geeignete Software. Sie können jedoch mehrere kostenlose Windowsprogramme im Internet finden.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

19

Abb. 9: PSPad unter Windows XP

Gute Erfahrungen haben wir mit den Programmen „PSPad” des tschechischen Programmierers Jan Fiala [PSPad] und „Notepad++“ von Don Ho aus Frankreich [NP++] gemacht. Nicht zu empfehlen ist der mit Microsoft Windows mitgelieferte primitive Texteditor „notepad.exe” alias „Editor“, da er manche Textdateien nicht oder nicht korrekt öffnet und weder eine Randleiste mit Zeilennummern anzeigen kann noch über Syntaxhervorhebung verfügt.

2.8.

Textverarbeitung

Textverarbeitungen und Textsatzsysteme erlauben es, längere strukturierte Texte layoutunabhängig zu erfassen und inhaltsunabhängig zu gestalten. Die Zuordnung von Inhalt und Form geschieht mittels so genannter Formatvorlagen (LibreOffice Writer, Microsoft Office Word, OpenOffice.org Writer), Styles (WordPerfect) oder Templates (TeX, LaTeX). So kann die Formatvorlage für eine Überschrift 2. Grades, wie sie beispielsweise über diesem Absatz steht, die Information enthalten, dass der Überschrift eine Kapitelnummer voranstehen soll, dass sie in 16 Punkt hoher Schrift in der Schriftart „DejaVu Sans“ gesetzt werden und fett gedruckt soll.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

20

Textverarbeitungen und Textsatzsysteme erstellen bei richtiger Anwendung automatisch Inhalts-, Abbildungs- und Literaturverzeichnisse, passen Texte und Abbildungen in den vorgesehenen Bereich ein und führen Querverweise innerhalb eines Textes automatisch nach. Es ist empfehlenswert, dass sie sich für die Hausaufgaben in diesem Fach zumindest aneignen, wie man mit dem von Ihnen bevorzugten Programm Überschriften korrekt setzt, die Rechtschreibkorrektur verwendet und Grafiken einbindet. Darüber hinaus ist das Thema „Textverarbeitung“ nicht Bestandteil dieses Kurses.

2.9.

Tabellenkalkulation

Tabellenkalkulationen gehören zu den ältesten Anwendungsprogrammen der PC-Geschichte.

Abb. 10: Tabellenkalkulation 1979

Bereits 1979 erschien die Tabellenkalkulation Visicalc für den Apple ][, einem der ersten je gebauten Personalcomputer. 1983 war Lotus 1-2-3 für das junge Betriebssystem DOS erhältlich, ein Jahr später brachte Microsoft für den Apple Macintosh die Tabellenkalkulation Excel auf den Markt. Excel war ein dermaßen originalgetreues Abbild von Lotus 1-2-3, dass es von diesem sogar den Fehler übernommen hat, das Jahr 1900 als Schaltjahr auszuweisen [Lisch08]. 1985 veröffentlichte Marco Börries das Programm StarOffice für den Schneider CPC, welches später zum freien Bürosoftwarepaket LibreOffice (bzw. OpenOffice.org) heranwuchs. 2006 schließlich machte Google mit der Browseranwendung „Text und Tabellen“ die Tabellenkalkulation unabhängig von einzelnen PCs und erlaubt es

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

21

sogar, mit mehreren Personen über das Internet gleichzeitig an einer Datei zu arbeiten. Allen Tabellenkalkulationen gemeinsam ist das Rechengitter oder Arbeitsblatt, in dessen Zellen Zahlenwerte, Texte oder Formeln gespeichert und ausgeführt werden können. Traditionell werden die Spalten dieses Arbeitsblattes mit Buchstaben und die Zeilen mit Zahlen bezeichnet. Die Zelle B3 ist also in der dritten Zeile der zweiten Tabellenspalte zu finden.

2.9.1.

Formeln

Beginnt der Inhalt einer Zelle mit einem Gleichheitszeichen, so wird der Zellinhalt als Formel interpretiert. Als Variablennamen werden in Formeln üblicherweise Zellenadressen verwendet.

Abb. 11: Formel einer Tabellenkalkulation

In der Abbildung können wir oben rechts erkennen, dass sich in der mit einem dicken schwarzen Rahmen hervorgehobenen Zelle B2 die Formel =0,19*A2 befindet, welche also 19 % des Wertes von Zelle A2 ausrechnet. Um Formeln lesbarer zu gestalten, können einzelnen Zellen oder ganzen Zellbereichen Namen zugewiesen werden. Die Namen müssen dabei stets mit einem Buchstaben beginnen, sie sollten möglichst mit einem Buchstaben enden (damit sie nicht mit einer Zellenadresse verwechselt werden) und sie dürfen nur aus den Buchstaben von „A” bis „Z“, dem Unterstrich „_“ und Ziffern bestehen. Umlaute und sonstige Sonderzeichen sind in der Regel nicht zulässig.

2.9.2.

Zellbereiche

Bezieht sich eine Formel nicht nur auf eine einzelne Zelle, sondern auf einen zusammenhängenden Bereich, so kann man diesen Bereich als von:bis formulieren. Soll in Feld A5 beispielsweise die Summe der Fel-

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

22

der A1 bis A4 ausgerechnet werden, so schreibt man diese als =SUMME(A1:A4).

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

23

Abb. 12: Bereichschreibweise

2.9.3.

Fallunterscheidungen

Innerhalb von Formeln können Entscheidungen auf der Grundlage logischer Aussagen getroffen werden. Der Funktion WENN() sind dazu drei durch Semikola1 getrennte Parameter zu übergeben: Die zu untersuchende Bedingung (logische Aussage), der Wert bei Erfüllung der Bedingung und der Wert bei ihrer Nichterfüllung. Als Beispiel seien in Spalte A, von Zelle A3 an abwärts, diverse Messwerte eingetragen. In Spalte B soll untersucht werden, ob diese einen Grenzwert (Zelle B1, welcher der Name „Grenzwert” zugewiesen wurde) nicht überschreitet. In Zelle B3 steht daher die Formel =WENN(A3>Grenzwert; "Alarm!"; "alles ok").

Abb. 13: Fallunterscheidung

1 Das ist kein Erfrischungsgetränk mit halbiertem Koffeingehalt, sondern der Plural von „Semikolon“: http://www.duden.de/rechtschreibung/Semikolon

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

24

2.9.4.

Diagramme

Alle Tabellenkalkulationen bieten recht komfortable Möglichkeiten, Diagramme aus eingetragenen oder berechneten Zellinhalten zu erzeugen. In der Regel ist dazu der Datenbereich zu markieren und im Menü „Einfügen“ der Menüpunkt „Diagramm“ zu wählen. Im Ingenieurwesen ist insbesondere die Diagrammform „x-y-Diagramm“ von Wert, da diese einen klaren Koordinatenbezug zwischen zwei Wertegruppen herstellen kann. In LibreOffice ist dazu der Diagrammtyp „XY“ auszuwählen. Bei Microsoft Office Excel sind die XY-Diagramme unter „Punkte“ versteckt.

Abb. 14: x-y-Diagramm

2.9.5.

CSV-Dateien

Alle Tabellenkalkulationen unterstützen neben ihrem eigenen, oft undokumentierten, Dateiformat ein sehr einfaches und universelles Datenaustauschformat, in dem die einzelnen Daten (Zahlen oder Texte) zeilenweise durch Kommas getrennt vorliegen. Nach diesen „kommagetrennten Werten“ oder „comma separated values“ heißen diese Dateien CSV-Dateien. Mustermann,Max,21,Bochum,44801 Exempel,Elvira,20,Gelsenkirchen,45879

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

25

Texte werden in CSV-Dateien in der Regel in Anführungszeichen gesetzt, anstelle des Kommas ist als Trennzeichen oft auch ein Semikolon üblich. "Mustermann";"Max";21;"Bochum";44801 "Exempel";"Elvira";20;"Gelsenkirchen";45879 Formeln oder Diagramme gehen beim Speichern einer Tabellenkalkulationsdatei als CSV-Datei verloren.

2.10. VPN – das virtuelle private Netzwerk Mit dem Kürzel VPN (Virtual Private Network) haben Sie an der Hochschule Bochum immer dann zu tun, wenn Sie auf gesicherte Bereiche eines Netzwerks (zum Beispiel Ihre Notenübersicht) über unsichere Kanäle (offenes WLAN) zugreifen wollen oder eine Verbindung zwischen dem internen Hochschulnetzwerk und externen Rechnern im Internet außerhalb der Hochschule benötigen. Das VPN überträgt alle Daten verschlüsselt, so dass dieselbe Sicherheit wie in einem gut geschützten privaten Netzwerk existiert. Für Microsoft Windows benötigen Sie zum Aufbau einer VPN-Verbindung eine „VPN Client“ genannte Zusatzsoftware eines Drittanbieters. In iOSGeräten ist die nötige Software schon enthalten und muss nur konfiguriert werden. Linux bietet ebenfalls unkomplizierte Möglichkeiten an, das VPN einzurichten. Für Android-Geräte gibt es derzeit (Dezember 2012) leider keine einfache Lösung, um auf den in der Hochschule verwendeten VPN-Typ (IPSec, Cisco-kompatibel) zuzugreifen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

26

3. Hypertext Bevor wir in Kapitel 4 mit der Einführung in die Programmierung beginnen, wollen wir zunächst einmal einen Blick in die formell strukturierte Welt einer typischen „Computersprache“ werfen. Eine der bekanntesten Sprachen, mit denen Texte so geschrieben werden können, dass sie sowohl von Menschen gelesen als auch von Computern richtig interpretiert werden, trägt den Namen „HTML”. Die „Hypertext Markup Language” HTML stellt Möglichkeiten zur Verfügung, Textstellen so zu markieren, dass Verbindungen zwischen ihnen hergestellt werden können, dass ihre Struktur gut wiedergegeben werden kann und dass Informationselemente wie Listen, Bilder und Tabellen einfach und ohne besondere Werkzeuge eingefügt werden können. Als Hypertext bezeichnen wir dabei einen strukturierten Text, der aktivierbare Komponenten enthält, mit denen eine Navigation von einer Textstelle zu einer bestimmten anderen Textstelle im selben oder einem anderen Hypertext möglich ist. Die Start- und Zielpunkte dieser Verweise nennen wir Anker. Die Verweise selbst werden als Links oder auch Hyperlinks bezeichnet. HTML ist zunächst einmal keine Programmiersprache: Sie ist nicht ohne weiteres dazu geeignet, wiederkehrende Prozesse zu automatisieren oder Berechnungen durchzuführen. Wir werden sie aber im Laufe dieses Semesters immer wieder dazu verwenden, Texte zu strukturieren und Inhalte für Webbrowser darstellbar zu machen. Hinter nahezu jeder Webseite steckt ein HTML-Text. Um diesen sichtbar zu machen, genügt es in den meisten Webbrowsern unter Windows oder Linux, die Tastenkombination Strg-U zu drücken. Was auf den ersten Blick wie ein chaotisches Gewimmel aus spitzen Klammern und kryptischen Abkürzungen anmutet, besitzt in Wirklichkeit eine klare Struktur. Meistens jedenfalls.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

27

3.1.

Tags

Die Markierungen, die in gewöhnliche Texte eingefügt werden müssen, damit aus diesen Hypertexte werden, heißen „Tags1“. In HTMLDateien sind sie auf den ersten Blick dadurch erkennbar, dass sie von spitzen Klammern umschlossen werden. Üblicherweise treten Tags paarweise auf. Zu einem öffnenden Tag (Starttag) gehört ein schließendes

Abb. 15: Tags sind Etiketten für Textabschnitte

Tag (Endtag), welches mit einem Schrägstrich eingeleitet wird.

3.2.

Hierarchische Ordnung

Starttag, Inhalt und Endtag bilden gemeinsam ein HTML-Element. Diese Elemente können ineinander verschachtelt sein, dürfen sich aber nicht überschneiden. Bevor ein übergeordnetes Element durch ein Endtag geschlossen wird, müssen zuerst alle untergeordneten Elemente geschlossen werden.

1 Das englische Wort „tag” bedeutet nicht nur Markierung, sondern auch Etikett, Anhänger, Aufkleber, Marke oder Auszeichner. Die Funketiketten zur Diebstahlsicherung kennen Sie bestimmt auch als "RFID-Tags", in Musikdateien werden die Informationen zu Titel und Interpret im "ID3-Tag" gespeichert und die Reviermarken von Sprühlackschmierern heißen ebenfalls "Tags".

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

28

Ein einfaches Beispiel dieser hierarchischen Ordnung zeigt das Diagramm

in

Abbildung

16.

Das

HTML-Element umfasst den gesamten Inhalt und gliedert sich in einen Kopfteil (head) und einen Inhaltsteil (body). Der Kopfteil einer HTML-Datei enthält oft Angaben zu Autor und Zeichenkodierung sowie Hinweise für Suchmaschinen und diverse andere Informationen, die auf der Webseite hinterher nicht direkt zu sehen sind. Im Beispiel wird nur das

Element „title” verwendet,

welches den vorderen Teil der Titelzeile des im nächsten Bild zu sehenden Webbrowsers festlegt. Der Inhaltsteil enthält den darzustellenden Text. In diesem Fall ist es der Ausruf „Schön, dass Sie da sind!”, welchem eine Überschrift ersten

Grades

mit

dem

Inhalt

„Hallo Welt” vorangestellt ist. Dass in dem Beispiel ausgerechnet das Wort „Schön“ so unschön

Abb. 16: HTML-Struktur

als „Schön“ daherkommt hat den Grund, dass diese Ersatzdarstellung auch unter ungünstigsten Bedingungen noch funktioniert. Mehr dazu in Kapitel 3.4. Diese HTML-Datei wird in einem Webbrowser vermutlich so ähnlich dargestellt werden, wie es die Abbildung rechts neben diesem Absatz zeigt1.

1 Solche Abbildungen eines Bildschirmfensters oder eines kompletten Bildschirms nennt man „Bildschirmfoto” oder auch „Screenshot“.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

29

Es ist gut möglich, dass das Erscheinungsbild

in

unterschiedli-

chen Browsern variiert, denn welche

Schriftart

verwendet

wird,

welche Abstände die Textbereiche untereinander haben und wie groß die verschiedenen Texte sind, steht nicht in der HTML-Datei. Es ist auch keine gute Idee, das durch „geschickte“

Verwendung

HTML-Strukturelementen

von festle-

Abb. 17: Der Browser stellt HTML-Seiten dar

gen zu wollen . Die Aufgabe der Sprache HTML liegt in der inhaltlichen 1

Strukturierung eines Textes. Für das Layouten gibt es geeignetere Mittel (siehe Kapitel 3.5).

3.3.

Attribute

Manche HTML-Tags sind mit Zusatzinformationen versehen, die wir „Attribute“ nennen. Attribute haben einen Namen und ihnen kann mittels eines Gleichheitszeichens ein Wert zugewiesen werden. Eine Textstelle, die auf eine andere Webseite verweisen soll, benötigt beispielsweise die Information, wie die Adresse der Seite lautet, die beim Anklicken angesprungen werden soll. Wir verwenden dazu das Ankertag „a”, indem wir ein HTML-Element anlegen, das aus dem zu markierenden Text besteht, der mit einem Start- und Endtag umschlossen ist und weisen im Starttag dem Attribut mit dem Namen „href“ den Wert „http://www.hs-bochum.de/” zu.

1 Das ändert nichts daran, dass es trotzdem immer wieder versucht wird.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

30

In einem geeigneten Texteditor sieht das fertige HTML-Element dann so aus:

Abb. 18: Bestandteile eines HTML-Elements

3.4.

HTML-Entitys

(…)

3.5.

CSS

(…)

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

31

4. Algorithmen und ihre Darstellung Ein Algorithmus ist eine Handlungsvorschrift, mit der sich eine Aufgabe in einer endliche Zahl von Lösungsschritten abarbeiten lässt. Bevor Sie damit beginnen, eine Computerprogramm zur Lösung eines Problems zu schreiben, ist es eine gute Idee, wenn Sie sich zuerst über den zugrunde liegenden Algorithmus Gedanken machen. Durch eine grafische Darstellung dieses Algorithmus lässt sich die Umsetzung in ein Programm oft erheblich vereinfachen. Für die Programmdokumentation ist ein Diagramm der Programmstruktur zudem ein unverzichtbarer Bestandteil, um eine gewählte Lösung nachvollziehbar festzuhalten.

4.1.

Flussdiagramme

Einfache Algorithmen lassen sich mit Flussdiagrammen grafisch darstellen. Pfeile zeigen die Reihenfolge der Ausführung an. Berechnungen werden durch Rechtecke dargestellt, Ein- und Ausgabevorgänge durch Parallelogramme mit waagerechter Grundseite und Fallunterscheidungen mit einer auf der Spitze stehenden Raute. lies zwei Zahlen a und b

ist b gleich null?

ja

gib Fehlermeldung aus

nein teile a durch b Abb. 19: einfaches Flussdiagramm

Komplexere Algorithmen oder Schleifen sind in Flussdiagrammen nur schlecht darzustellen, daher verwendet man zur Darstellung von nicht trivialen Algorithmen in der Regel die im Folgenden vorgestellten Strukto-

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

32

gramme. In Kapitel 5.19.5 auf Seite 73 sind beide Darstellungsformen am Beispiel verschachtelter Schleifen gegenübergestellt.

4.2.

Struktogramme

Struktogramme stellen eine besonders übersichtliche Form dar, einen Algorithmus grafisch darzustellen. Der Programmlauf erfolgt streng von oben nach unten, Schleifen werden – wie im Python-Quelltext – eingerückt und bei Fallunterscheidungen gliedert sich das Struktogramm in mehrere Spalten auf.

4.2.1.

Sequenzen

Programmteile, die nacheinander ausgeführt werden sollen, werden im Struktogramm als untereinander liegende Rechtecke mit gleicher Breite dargestellt. In den Rechtecken steht der jeweilige Ar-

Abb. 20: Struktogramm: Sequenz

beitsschritt in Kurzform oder als Formel.

4.2.2.

Fallunterscheidungen

Gibt es in einem Algorithmus zwei Ausführungsalternativen, die von einer zu treffenden Entscheidung abhängen, so gliedert sich das Struktogramm

in

zwei

Spalten

auf. Die Kopfzeile der Fallunterscheidung ist dreigeteilt. Das obere Dreieck enthält die Frage und die beiden unteren Dreiecke die bei-

Abb. 21: Struktogramm: Fallunterscheidung

den möglichen Antworten. Je nachdem, welche Antwort die richtige ist, wird nur der Ausführungszweig in der zugehörigen Spalte weiter betrachtet. Ausführungszweige dürfen auch leer sein.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

33

Wird der Algorithmus im weiteren Verlauf wieder unabhängig vom gewählten Ausführungszweig abgearbeitet, so werden die gemeinsamen Ausführungsschritte wieder in voller Breite dargestellt.

4.2.3.

Mehrfachauswahl

Bestehen mehr als zwei Wahlmöglichkeiten, so gliedert sich das Struktogramm

in

entsprechend

viele Spalten auf. Die letzte Wahlmöglichkeit ergibt sich häufig aus den anderen und muss dann nicht mehr explizit formuliert werden.

Abb. 22: Struktogramm: Mehrfachauswahl

Da die Darstellung der Mehrfachauswahl im Struktogramm bedingt, dass eine Spalte gegenüber den anderen abgesetzt wird, ist es eine gute Idee, hierzu diesen letzten Fall „ansonsten“ zu verwenden.

4.2.4.

Abweisende Schleife

Schleifen sind Abschnitte in einem Algorithmus, die mehrmals hintereinander wiederholt werden können. Über die Anzahl der Wiederholungen (null bis unendlich) entscheidet die im Schleifenkopf formulierte Schleifenbedingung. Vor je-

Abb. 23: Struktogramm: Schleife

dem Schleifendurchlauf wird die Bedingung geprüft – ist sie erfüllt, wird die Schleife ausgeführt. Wenn die Schleifenbedingung bereits bei der ersten Prüfung nicht erfüllt ist, wird der Schleifenkörper niemals betreten. Man nennt diesen Schleifentyp daher auch abweisende Schleife. Der zu wiederholende Schleifenkörper ist im Struktogramm stets eingerückt.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

34

4.2.5.

Nichtabweisende Schleife

Wenn die Schleifenbedingung erst zum Ende der Schleife geprüft wird und der Schleifenkörper daher

immer

mindestens

einmal

durchlaufen wird, spricht man von einer nichtabweisenden Schleife. Python hat keine eigenen Sprachelemente

für

nichtabweisende

Abb. 24: Struktogramm: Nichtabweisende Schleife

Schleifen. Hier verwendet man in der programmiertechnischen Umsetzung stattdessen eine Hilfskonstruktion, die der Endlosschleife mit Aussprung aus Kapitel 4.2.7 entspricht.

4.2.6.

Endlosschleife

Endlosschleifen sind Schleifen, deren Schleifenbedingung immer erfüllt ist. Ungeplante Endlosschleifen treten oft als Folge eines Programmierfehlers auf, der erst bei der Programmausführung bemerkt wird – indem beispielsweise beim Testen zweier Zahlenwerte auf Gleichheit Rundungsfehler nicht berücksich-

Abb. 25: Struktogramm: Endlosschleife

tigt werden. Bei kleinen Programmen, die nur geschrieben werden, um nacheinander einige Zahlenwerte auszurechnen, kann eine Endlosschleife aber auch bewusst verwendet werden. Ein Python-Programm lässt sich dann immer noch mit der Tastenkombination Strg-C stoppen oder über den FensterSchließen-Button des Betriebssystems beenden. Ist eine Endlosschleife gewollt, wird sie im Struktogramm durch einen nach rechts eingerückten „schwebenden“ Block dargestellt.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

35

4.2.7.

Endlosschleife mit Aussprung

Endlosschleifen können auch programmgesteuert

verlassen

wer-

den. Dazu wird eine Abbruchbedingung im Verlauf der Abarbeitung des Schleifenkörpers getestet. Ist sie erfüllt, erfolgt ein gezielter

Aussprung.

Siehe

dazu

auch Kapitel 5.19.2 auf Seite 69. Der Algorithmus wird nach dem Aussprung unterhalb der Schleife fortgesetzt. Hinweis für alle, die schon eine Programmiersprache gelernt haben:

In

Pythonprogrammen

ist

Abb. 26: Struktogramm: Endlosschleife mit Aussprung

diese Konstruktion relativ häufig anzutreffen, da die Sprache keine Schlüsselwörter für nichtabweisenden Schleifen kennt (repeat … until, do … while, do … loop until etc.). Es spricht jedoch nichts dagegen, die Algorithmen hinter dem Programm in der übersichtlicheren Form nach Kapitel 4.2.5 darzustellen.

4.2.8.

Beispiel für ein vollständiges Struktogramm

Das folgende Struktogramm gibt einen Algorithmus wieder, mit dem sich in höchstens zehn Versuchen jede vom Benutzer ausgedachte ganze Zahl zwischen 1 und 1000 ermitteln lässt. Die Rückmeldung erfolgt über einen Tastendruck T. Ist die ausgedachte Zahl größer als die von Algorithmus „geratene“, so soll ein Minuszeichen eingegeben werden, ist sie zu groß, soll ein Pluszeichen eingegeben werden und jede andere Eingabe zeigt an, dass die Zahl geraten wurde. Der Algorithmus bestimmt dazu ein Suchintervall mit Ober- und Untergrenze (UG und OG). Anfangs liegen diese Werte bei 1 und 1000. Mit jedem Rateversuch wird das Intervall halbiert. Die Funktion int() sorgt dafür, dass das Ergebnis der Halbierung wieder eine ganze Zahl ist. Nach

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

36

spätestens 10 Halbierungen hat das Suchintervall die Größe 1 und die Zahl ist gefunden.

Abb. 27: Struktogrammbeispiel „Zahlenraten“

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

37

5. Python Es gibt zahlreiche spezielle Programmiersprachen für die verschiedensten Anwendungsgebiete von der kaufmännischen Buchhaltung bis zur künstlichen Intelligenz. Einige Sprachen funktionieren nur innerhalb eines bestimmten Softwarepakets, es gibt aber auch Sprachen, die universell für eine Vielzahl von Aufgabenstellungen einsetzbar sind. Manche von denen sind schwer zu erlernen, andere wiederum bieten so gut wie keine Einstiegshürden. Gelegentlich werden Sprachen nur für ein bestimmtes Betriebssystem (man sagt auch: für eine bestimmte Plattform) angeboten, es gibt jedoch auch Sprachen, die für eine Vielzahl von Plattformen erhältlich sind. Nicht zuletzt kann man für Programmiersprachen richtig viel Geld bezahlen – oder sie kostenlos herunterladen. Aus all diesen Überlegungen heraus haben wir uns für die Sprache Python entschieden, die 1991 von Guido van Rossum entworfen wurde. Python ist kostenlos, läuft auf zahlreichen Betriebssystemen, ist sehr einfach zu erlernen, eignet sich jedoch als Vielzwecksprache für

zahlreiche

unterschiedliche

Anwendungsgebiete. Sie ist objektorientiert und besitzt nur wenige

Sprachelemente,

ist

aber

durch Bibliotheken fast beliebig erweiterbar. Außerdem ist sie eine Skriptsprache, die direkt eingetippt und ausgeführt werden kann und keine Compilersprache, die erst aufwän-

Abb. 28: Guido van Rossum 2006 (dsearls, CC-BY-SA 2.0)

dig in ein ausführbares Programm übersetzt werden muss.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

38

5.1.

Download und Installation

Python ist frei erhältlich. Die Downloadpakete für Windows und Mac OS gibt es auf http://www.python.org/download/ [PyO]. Linux-Anwenderinnen und -Anwender können Python einfach über die Paketverwaltung installieren. Achten Sie darauf, dass es zwei unterschiedliche Versionen von Python gibt, deren Quelltexte nicht ohne weiteres untereinander austauschbar1 sind, da Python von Version 2 zu Version 3 erheblich aufgeräumt wurde. Wir befassen uns in diesem Kurs nur mit Python 3. Nach der Installation lässt sich die integrierte

Entwicklungsumge-

bung IDLE unter Windows und Linux über das Startmenü aufrufen. Unter Windows2 finden Sie IDLE 3 unter „Start - (Alle) Programme – Python 3.x – IDLE (Python GUI)“

Abb. 29: Das Startmenü von Windows 7

oder Sie drücken die Windows-Taste und tippen „id…“. Unter Linux3 ist die Entwicklungsumgebung unter „Anwendungen – Softwareentwicklung – IDLE 3“ einsortiert.

5.2.

Erste Schritte in der Python-Shell von IDLE

Die Entwicklungsumgebung IDLE kommt recht schmucklos daher. Ein paar Zeilen Text mit Versionsnummern und drei farblich abgehobene größer-als-Zeichen mit einem senkrechten Strich dahinter sind zunächst scheinbar alles, was angeboten wird:

1 In der EDV bezeichnet man solche mangelnde Austauschbarkeit als „Inkompatibilität“. 2 „Windows“ wird hier vereinfachend als Synonym für die Betriebssysteme „Microsoft Windows XP“, „Microsoft Windows 7“ und „Microsoft Windows 8“ benutzt. 3 „Linux“ wird hier vereinfachend für „Ubuntu GNU/Linux“ mit Gnome oder Unity Desktopumgebung verwendet.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

39

Abb. 30: Die Python-Shell der Entwicklungsumgebung IDLE

Die drei größer-als-Zeichen „>>>“ bilden den sogenannten Prompt. Mit ihm gibt Python zu erkennen, dass es alle Aufgaben bearbeitet hat und nun auf Benutzereingaben wartet. Der senkrechte Strich dahinter ist der Cursor, der die aktuelle Schreibposition anzeigt. Ohne einen einzigen Python-Befehl zu kennen, können Sie die Shell jetzt schon als eine Art einfachen Taschenrechner verwenden, der immerhin Klammern kennt und die Priorität von Punktrechnung vor Strichrechnung beherrscht:

Abb. 31: Die Python-Shell als Taschenrechner

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

40

Bei der Division fallen zwei Dinge auf: die letzte Stelle des Ergebnisses ist nicht gerundet, sondern abgeschnitten1 und als Dezimalzeichen wird der Punkt und nicht das Komma verwendet. Die letzte Eingabezeile zeigt, dass Python auch mit Texten umgehen kann. Sofern Zeichenfolgen mit Anführungszeichen oder HochKommas umschlossen werden, gibt Python sie unverändert wieder. Fehlen die Anführungszeichen, so versucht Python, die Eingabe als Befehl oder Variablenname zu verstehen.

5.3.

Fehlermeldungen

Python-Fehlermeldungen wirken auf den ersten Blick ziemlich alarmierend, unverständlich und unfreundlich, sind tatsächlich aber eine große Hilfe bei der Fehlersuche in einem Programm. So wird immer die Zeile im Quelltext angegeben, an der der Fehler aufgetreten ist und eine (englischsprachige) Beschreibung der Fehlerumstände hilft, die Fehlerursache schnell zu erkennen.

Abb. 32: Python-Fehlermeldungen

Der einfachste Fehler ist der Syntaxfehler; er tritt auf, wenn ein Wort falsch geschrieben wurde oder an der falschen Stelle steht. Bei komplexeren Fehlern (diese werden auch „Ausnahmen“ genannt) ist die Fehlermeldung länger. Die letzte Zeile der Fehlermeldung gibt dann den Grund für die Ausnahme an und in der zweiten Zeile der Fehlermeldung finden wir 1 Wer das bei 1/7 nicht erkennt, möge das Experiment mit 2/3 wiederholen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

41

die Zeile im Programmtext, an der der Fehler aufgetreten ist. Hier oder in der Zeile darüber ist meistens irgendetwas zu reparieren. Anfangs ist es völlig normal, dass ein Programm anstelle der gewünschten Ergebnisse zahlreiche Fehlermeldungen ausgibt. Lassen Sie sich dadurch nicht entmutigen, Fehler gehören zum Programmieren dazu. Nach dem Schreiben eines Programms heißt die nächste Arbeitsphase immer „Fehlersuche“ oder, weil Programmierfehler traditionell als Bugs bezeichnet werden, „Debugging“. In IDLE gibt es dazu sogar einen eigenen Menüpunkt in der Hauptmenüleiste. Eine Tabelle mit den häufigsten Fehlermeldungen, ihrer Übersetzung und Ratschlägen zur Vermeidung und Behebung befindet sich im Anhang dieses Lehrbuchs auf Seite 126.

5.4. In

Variablen

Programmiersprachen

lassen

sich Variablen als eine Art benannte Behälter verwenden, in denen Zahlen oder Zeichenketten zur späteren Verwendung aufbewahrt werden können. Die Zuweisung eines Wertes zu einer Variablen geschieht mit dem

Abb. 33: Wir können uns Variablen zunächst als kleine beschriftete Kästchen vorstellen.

Zuweisungszeichen „=“. Es ist anfangs eine gute Idee, dieses Zuweisungszeichen als „wird zu“ und nicht als „gleich“ zu lesen, um es nicht mit dem identisch aussehenden Gleichheitszeichen aus der Mathematik zu verwechseln. Jeder Variable kann beliebig oft ein neuer Wert zugewiesen werden.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

42

Abb. 34: Eine Variable behält ihren Wert, bis ihr ein neuer zugewiesen wird

5.4.1.

Variablennamen

Variablennamen bestehen aus einer ununterbrochenen Folge von Buchstaben, Ziffern und Unterstrichen „_“. Das erste Zeichen darf keine Ziffer sein. Im Gegensatz zu vielen anderen Programmiersprachen erlaubt Python auch Buchstaben, die nicht im klassischen 26-Zeichen-Alphabet zu finden sind.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

43

Gültige Variablennamen sind beispielsweise: xx _x_ x_min 変数名 Schalke04 Öffnungsmaß KamelSchreibweise Ich_habe_einen_langen_Namen_und_ich_werde_ihn_benutzen Der Inhalt einer Variablen lässt sich abfragen, indem der Variablenname am Prompt eingegeben1 wird.

5.5.

Eingabe mit input()

Um in einem Programm eine Zeichenfolge von der Tastatur einzulesen, gibt es die Funktion input(). Ihr Rückgabewert kann einer Textvariablen zugewiesen werden.

Abb. 35: Eingabedialoge

Die Klammer ist, wie bei jeder Funktion, zwingend notwendig. Sie darf leer sein, kann aber auch einen Fragetext enthalten, um dem Bediener oder der Bedienerin mitzuteilen, welche Eingabe erwartet wird.

1 „Eingeben“ heißt, etwas zu tippen und dann die Eingabetaste ↲ (Enter-Taste) zu drücken.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

44

5.6.

Ausgabe mit print()

Die Funktion print() gibt die ihr übergebenen Inhalte auf dem Bildschirm oder in eine Datei aus und beginnt danach eine neue Zeile.

Abb. 36: Ausgabe mit print()

Zwischen den Klammern dürfen beliebig viele durch Kommas getrennte Parameter, die sogenannten Argumente der Funktion, stehen. Bei der Ausgabe werden sie, jeweils getrennt durch ein Leerzeichen, hintereinander geschrieben. Bleibt die Klammer leer, wird nur eine Leerzeile ausgegeben.

5.6.1.

Alternatives Trennzeichen

Anstelle des Leerzeichens können beliebige

andere

Zeichenfolgen

als

Zeichen

oder

Trennzeichen

zwischen den mit print() auszugebenden Parametern verwendet werden. Diese auch Separatoren genannten

Trennzeichen

werden

über

Abb. 37: Alternative Separatoren

den zusätzlichen Parameter sep an die Funktion übergeben. Um beispielsweise die Inhalte der drei Variablen a, b und c mit jeweils einem Semikolon getrennt hintereinander auszugeben, schreiben wir print(a, b, c, sep=";"). Wird als Separator die leere Zeichenkette "" eingestellt, so gibt Python die Parameter direkt hintereinander aus.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

45

5.6.2.

Alternatives Zeilenende

Wenn es nicht gewünscht ist, dass nach der Ausgabe eine neue Zeile begonnen wird, oder wenn am Ende einer Zeile ein besonderes Zeichen stehen soll, so kann dieses Verhalten mit dem Parameter end beeinflusst werden. Der Standardinhalt von end ist der Zeilenwechsel "\n", es ist aber auch

jede

andere

Zeichenfolge

einschließlich des Leerstrings "" möglich. Soll beispielsweise nach der Ausgabe der drei Variablen a, b und c ohne

Zeilenwechsel

weiterge-

schrieben werden, so lässt sich Abb. 38: Zwei print-Ausgaben in einer Zeile

das mit print(a, b, c, end="") bewerkstelligen.

5.7.

Einfache Datentypen

Einfache Variablen speichern genau einen Wert. Das kann eine Zahl sein, wahlweise mit oder ohne Dezimalstellen, eine Zeichenkette oder ein Wahrheitswert. In Anlehnung an die englischsprachigen Bezeichnungen werden diese Datentypen in Python kurz int, float, str und bool genannt.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

46

Englische Bezeichnung

KurzbezeichBeispiel für eine nung in PyKonstante des Typs thon

Ganzzahl

integer

int

42

Gleitkommazahl

floating-point number

float

3.141592653589793

Zeichenkette

string

str

"Hallo Bochum!"

Wahrheitswert

Boolean value

bool

True

Deutsche Bezeichnung

Die Zeichenkettenkonstante muss von Anführungszeichen umschlossen werden, um nicht mit Variablennamen verwechselt zu werden. Bei der Ein- und Ausgabe von Gleitkommazahlen ist darauf zu achten, dass in Python (wie auch in fast allen anderen Programmiersprachen) als Dezimalzeichen ein Punkt zu setzen ist. Das Komma hat als Trennzeichen eine eigene Bedeutung.

5.8.

Typumwandlung

In Python ist es möglich, den Typ einer Variablen jederzeit zu ändern. Einer Variablen, die eine Zeichenkette enthält, kann stattdessen ohne weiteres eine Gleitkommazahl zugewiesen werden. Der Variablentyp ändert sich dadurch automatisch.1 Gelegentlich ist es in einem Python-Programm erforderlich, den Typ einer Variablen gezielt zu verändern. Für die uns bekannten Variablentypen stehen dazu die Funktionen int(), float(), str() und bool() zur Verfügung. Im Beispiel rechts wird eine Zeichenkette, die das Zeichen „3“ enthält, in eine Ganzzahl mit dem Zahlenwert 3 umgewandelt.

1 Viele andere Programmiersprachen erlauben eine solche dynamische Typisierung nicht. Dort muss gegebenenfalls schon vor der Verwendung einer Variable explizit deren Typ festgelegt werden.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

47

Mit dieser Zahl lässt sich anschließend wie gewünscht rechnen. Insbesondere

Tastatureingaben

mittels input() müssen erst in einen

Zahlentyp

umgewandelt

werden, wenn sie als numerische Werte

weiterverarbeitet

werden

sollen, denn die input()-Funktion gibt in Python 3 immer eine Zeichenkette zurück, selbst wenn nur Ziffern eingetippt wurden. Wir können diese Umwandlung entweder

in

zwei

Schritten vornehmen …

getrennten Abb. 39: Typumwandlung

a0 = input("Gib eine Zahl ein: ") a = int(a0) … oder wir fassen die beiden Schritte elegant zusammen und sparen dadurch sowohl eine Programmzeile als auch etwas Tipparbeit ein: a = int(input("Gib eine Zahl ein: ")) Auf diese Art verschachtelte Funktionen werden vom Python-Interpreter stets in der Reihenfolge „von innen nach außen“ ausgewertet.

5.8.1.

Evaluation von Ausdrücken

Python-Ausdrücke, die als Zeichenkette vorliegen, wie beispielsweise "13 * 17", "'Zeichen' + 'kette'" oder "sin(1/x)" können mit der Funktion eval() ausgewertet (evaluiert) werden.

Abb. 40: Evaluation eines arithmetischen Ausdrucks

Entdeckt Python in der Zeichenkette Variablennamen, werden die aktuellen Werte dieser Variablen dort eingesetzt; findet es Funktionen, so werden diese ausgeführt.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

48

Die

Funktion

eval()

bietet

sich

als

perfekte

Ergänzung

zur

input()-Funktion an. Abhängig von der jeweiligen Eingabe hat der Rückgabewert von eval(input()) immer den richtigen Typ1. Der Vorteil von

eval(), auch beliebige Funktionen auszuführen, kann

aber auch zu einem Sicherheitsrisiko werden, falls Python-Programme von böswilligen Personen ausgeführt werden. Für Pythonprogramme auf Webservern gilt daher ein striktes Verbot für die Benutzung von eval().

5.9.

Das erste richtige Programm

Bis jetzt haben wir jeden Python-Befehl einzeln in die Shell getippt, damit er ausgeführt wird. Um Befehle, die stets in einer bestimmten Reihenfolge ausgeführt werden sollen, nicht immer wieder neu schreiben zu müssen, können wir diese als Datei speichern. Die Folge von Befehlen nennen wir „Programm“ oder auch „Quelltext“ und die Textdatei mit den Programmbefehlen ist dementsprechend eine „Programmdatei“.

Abb. 41: Unser erstes Python-Programm

Um in IDLE eine neue Programmdatei anzulegen, drücken wir die Tastenkombination Strg+N oder wählen die Menüfolge „File – New Window“. Es erscheint ein leeres Fenster, in das wir nun unseren Programmtext eintippen können. Mit der Taste F5 oder über die Menüfolge „Run – Run Module“ können wir das Programm starten. Vorher wird es automatisch gesichert. Beim ersten Start werden wir gefragt, in welcher Datei das Programm gespeichert werden soll. Es ist eine gute Idee, den gewählten Dateinamen auf „.py“ enden zu lassen, damit sofort klar ist, dass es sich dabei um ein 1 In Python 2 war diese Umwandlung noch in die input()-Funktion eingebaut. Wer tatsächlich die buchstabengetreue Eingabe im Programm verwenden wollte, musste dort auf die Funktion raw_input() zurückgreifen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

49

Abb. 42: Der Programmlauf in der Python-Shell

Python-Programm handelt. Die meisten Editoren stellen außerdem die farbliche Syntaxhervorhebung eines Python-Programms erst dann dar, wenn die Datei korrekt als .py-Datei gespeichert wurde. Falls die Dateiendung „.py“ unter Microsoft Windows nicht angezeigt wird, empfiehlt sich in Blick in Kapitel 2.4.

5.10. Kommentare Um ein Programm nachvollziehbar zu halten, können hinter oder zwischen die auszuführenden Zeilen Bemerkungen

geschrieben

wer-

den. Zur Kennzeichnung von Kommentaren wird das Zeichen # verwendet,

welches

meistens

„Hash“

oder „Raute“ genannt wird. Sobald

der

dem Zeichen

Python-Interpreter #

begegnet, wird

der Rest der Zeile von ihm ignoriert. Mehrzeilige Kommentare können mit drei Anführungszeichen eingeleitet und abgeschlossen werden. Es ist möglich, ganze Programmabschnitte "auszukommentieren", um sie vorübergehend oder dauerhaft von der Ausführung auszu-

Abb. 43: Kommentare im Python-Quelltext

schließen. Der IDLE-Editor hat dazu einen eigenen Menüpunkt „Comment Out Region“ im Menü „Format“.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

50

Es ist eine gute Idee, auch eigene Programme möglichst umfassend durch Kommentare zu dokumentieren, weil der offensichtliche und unmittelbar einleuchtende Grund, etwas auf eine bestimmte Art programmiertechnisch umzusetzen, schon nach einem halben Jahr sehr im Dunkeln liegen kann. Eine besondere Form des Kommentars wird dazu verwendet, einen kurzen Hilfstext zu selbstgeschriebenen Funktionen auszugeben. Wenn zu Beginn einer Funktion eine Textkonstante ohne weitere Zuweisung formuliert wird, so wird dieser Text ausgegeben, wenn die Funktion help() mit dem Namen der Funktion aufgerufen wird.

5.10.1. Shebang und Zeichenkodierung Unter Linux und Mac OS hat die erste Zeile eines Quelltextes eine besondere Funktion: Diese auch im Deutschen Shebang1 genannte Zeile gibt dem Betriebssystem an, mit welchem Programm der Quelltext ausgeführt werden soll. Sind zum Beispiel auf dem Rechner sowohl Python 2 (als /usr/bin/python) als auch Python 3 (als /usr/bin/python3) vorhanden, so kann man einfach alle Python-2-Programme mit #!/usr/bin/python und alle Python-3-Programme mit #!/usr/bin/python3 einleiten, damit das Betriebssystem immer den richtigen Python-Interpreter für die Ausführung zur Verfügung stellt. Unter Microsoft Windows ist die Information, mit welchem Programm eine Datei geöffnet wird, fest an die Dateinamenerweiterung .py gebunden, deshalb gibt es dort in der Regel Probleme, wenn mehrere Pythonversionen installiert sind und eine Pythondatei beispielsweise durch Doppelklick im Windows Explorer gestartet werden soll. In der zweiten Zeile des Python-Quelltextes kann eine Zeichenkodierung angegeben werden. Dies ist vor allem dann sinnvoll, wenn der Quelltext Sonderzeichen enthält, die nicht in der Standardkodierung des Betriebs-

1 Man kann „Shebang“ mit „Gedöns“ übersetzen, aber das führt zu nichts.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

51

systems2 enthalten sind. Eine typische Angabe zur verwendeten Zeichenkodierung sieht zum Beispiel so aus: # -*- coding: utf-8 -*Die dekorativ aussehenden „-*-“ werden von Python selbst nicht benötigt, folgen aber dem Standard bestimmter verbreiteter Texteditoren. Mit den technischen Hintergründen der Zeichenkodierung beschäftigen wir uns in Kapitel 6, das den Titel „Datenspeicherung und Zahlensysteme“ trägt.

5.11. Rechenoperationen Python unterstützt die Grundrechenarten und beachtet dabei die aus der Mathematik bekannte Ausführungsreihenfolge: Punktrechnung geht vor Strichrechnung, eine noch höhere Priorität haben Potenzen, und Klammern stehen über allem. Alle Operatoren wie Plus + und Minus - sind über eine gewöhnliche Tastatur eingebbar, daher wird anstelle des Multiplikationspunktes · oder Multiplikationskreuzchens × der Stern * und anstelle des BruchstrichSymbols ÷ der Schrägstrich / verwendet. Potenziert wird nicht durch Hochstellen, sondern durch ein Doppelsternchen **. Für ganzzahlige Divisionen (zum Beispiel „14 durch 4 ergibt 3, Rest 2“) verwendet Python die Operatoren // und %. Dabei erhält man mit dem Opera-

Abb. 44: Ganzzahlige Division und Modulo

tor // den ganzzahligen Quotienten zweier Zahlen und mit % den dazu gehörenden Divisionsrest. Das Zeichen % wird hier auch Modulo-Operator genannt.

2 Mit Ausnahme von Microsoft Windows kann eigentlich jedes aktuelle Betriebssystem mit der zum Unicode kompatiblen UTF-8-Kodierung umgehen. Siehe Kapitel 2.6.2.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

52

5.11.1. Verkürzte Arithmetiknotation Taucht ein Variablenname beiderseits der Zuweisungszeichens = auf, so erlaubt Python eine verkürzte Schreibweise, in der der Variablenname auf der rechten Seite der Zuweisung fortgelassen werden kann. Zur Kennzeichnung dieses Vorgangs wird der Operator dem Zuweisungszeichen vorangestellt.

Abb. 45: Verkürzte Arithmetiknotation

Besonders bei Zählschleifen wird diese verkürzende Schreibweise gern angewendet.

5.12. Mathematische Funktionen: das Modul math Von Haus aus sind in Python nur wenige mathematische Funktionen fester Sprachbestandteil. Über abs(a) (für den Betrag oder Absolutwert einer Zahl a) oder round(b,c) (um eine Zahl b auf c Stellen zu runden) gehen die mathematischen Fähigkeiten der eingebauten Funktionen nicht hinaus. Um Python-Programme mit zusätzlichen Funktionen auszustatten, kann man diese Funktionen aus anderen Programm-Modulen importieren.1 Eines der am häufigsten verwendeten Module ist das Mathematikmodul math. Um beispielsweise die trigonometrischen Funktionen sin(), cos() und tan() verwenden zu können, schreibt man an den Anfang eines Programms from math import sin, cos, tan 1 Python wird mit einer großen Zahl vorgefertigter Module ausgeliefert. In Kapitel 5.25 lernen wir sogar, eigene Module zu schreiben.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

53

oder (wenn man tippfaul ist) from math import * In letzterem Fall stehen nach dieser Zeile alle Funktionen des Mathematikmoduls im gerade ausgeführten Programm zur Verfügung. Einige Beispiele für Funktionen des math-Moduls sind in der folgenden Tabelle aufgeführt. Funktionsname

Beschreibung

floor(a)

nächstkleinere oder gleiche Ganzzahl

ceil(a)

nächstgrößere oder gleiche Ganzzahl

sin(x) cos(x) tan(x)

Winkelfunktionen Sinus, Kosinus und Tangens. Der Winkel ist stets in Bogenmaß anzugeben!

asin(a) acos(b)

Die Umkehrfunktionen von Sinus und Kosinus (in der Mathematik oft als sin-1() und cos-1() geschrieben) ermitteln zu einer Zahl zwischen -1 und 1 den dazugehörigen Winkel in Bogenmaß.

atan(c) atan2(a,b)

Die Tangensfunktion hat gleich zwei Umkehrfunktionen: atan() nimmt die Steigung als einzelnen Zahlenwert entgegen; atan2() benötigt zwei Zahlen (Gegenkathete und Ankathete).

radians(w)

Rechnet einen Winkel von Altgrad in Bogenmaß um.

degrees(x)

Rechnet einen Winkel von Bogenmaß in Altgrad um.

sqrt(x)

Quadratwurzel (square root). Kann auch ohne Verwendung des math-Moduls als x**0.5 geschrieben werden.

exp(x)

Exponentialfunktion ex

pow(a,b)

Potenzfunktion ab – identisch mit a**b

log(b)

Natürlicher Logarithmus (Basis e)

log10(b) oder log(b,10)

Dekadischer Logarithmus (Basis 10)

5.13. Verzweigungen Nicht immer sind Programmabläufe so linear wie in den vorangegangenen Übungsaufgaben. Häufig ist die Ausführung von untergeordneten Programmteilen an bestimmte Bedingungen geknüpft.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

54

Auch zur Vermeidung von Fehlern während der Programmausführung (sogenannte Laufzeitfehler) ist es sinnvoll, vor bestimmten Berechnungen die Eingangswerte zu überprüfen. Nur wenn die Eingangswerte plausibel sind, ist die Berechnung sinnvoll. So treten beispielsweise in Berechnungen Fehler vom Typ „math domain error“ auf, wenn der Ausdruck unter einer Wurzel (beziehungsweise das Argument, das wir der Funktion sqrt() übergeben) negativ ist oder der Arkussinus einer Zahl ausgerechnet werden soll, die nicht im Intervall [-1, 1] liegt. Die Entscheidung darüber, ob ein Programm bestimmte Befehle ausführt oder nicht, wird mit Hilfe der so genannten logischen Aussagen getroffen.

5.14. Logische Aussagen Logische Aussagen sind Aussagen, die objektiv bestimmbar entweder eindeutig wahr oder eindeutig falsch sind. „4 ist größer als 3“ ist beispielsweise eine logische Aussage, da sie eindeutig als wahr oder falsch erkannt werden kann. „Der Hut ist schön“ ist dagegen keine logische Aussage, sondern eine subjektive Meinungsäußerung. Für die beiden Wahrheitswerte „wahr“ und „falsch“ gibt es in Python die beiden Schlüsselwörter True und False.

5.14.1. Vergleichsoperatoren Um logische Aussagen über das Größenverhältnis zweier Werte zu treffen, verwenden wir sechs verschiedene Operatoren: ist gleich

==

ist ungleich

!=

ist kleiner als ist kleiner oder gleich ist größer als ist größer oder gleich

< >=

5.14.2. Logische Aussagen über Gleitkommazahlen Während ganze Zahlen immer mit ihrem exakten Wert gespeichert und verarbeitet werden, sind Gleitkommazahlen sehr oft nur Näherungswerte

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

55

und unterliegen Rundungsfehlern. Intern werden Gleitkommazahlen oft als Produkt einer ganzen Zahl mit einer Zweierpotenz verarbeitet und erst bei der Ausgabe in eine Dezimalzahl mit einer bestimmten Anzahl von signifikanten Stellen umgewandelt. Wir sollten uns daher davor hüten, Gleitkommazahlen

jemals

auf

Gleichheit zu testen.

Abb. 46: Rundungsfehler bei Gleitkommaoperationen

Auch das Aufaddieren von Gleitkommazahlen bis zum Erreichen eines bestimmten Grenzwertes führt oft zu Überraschungen. Wer sichergehen will, dass das Programm sich wie erwartet verhält, sollte besser auf Ähnlichkeit anstatt auf Gleichheit testen. Die unten wiedergegebene Funktion1

ungefährgleich(a,b,epsilon)

liefert True zurück, wenn das Verhältnis von a zu b um nicht mehr als ein erlaubtes Maß epsilon von 1 abweicht. Falls b null sein sollte, wird stattdessen der Absolutwert von a mit epsilon verglichen. Beim Aufruf der Funktion kann epsilon weggelassen werden, es wird dann automatisch auf 0.0000001 gesetzt.

1 Mehr dazu, wie man Funktionen selbst definieren kann, steht in Kapitel 5.23 auf Seite 94.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

56

Abb. 47: Test zweier Zahlen auf Ähnlichkeit.

5.15. Boolesche Algebra Logische

Aussagen

lassen

sich

miteinander verknüpfen. So entsteht eine neue logische Aussage, die ebenfalls wieder den Wahrheitswert „wahr“ oder „falsch“ besitzt. Die drei wichtigsten Operatoren zur Verknüpfung logischer Aussagen

sind

„und“,

„oder“

sowie

Abb. 48: George Boole, 1815–1864

„nicht“ (in Python: and, or und not). Der englische Mathematiker George Boole stellte dazu die Regeln der später nach ihm benannten booleschen Algebra auf.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

57

5.15.1. Die Konjunktion: and

Abb. 49: Wahrheitstabelle and

Die Verknüpfung zweier logischer Aussagen mit and ergibt eine neue logische Aussage, die nur dann wahr ist, wenn beide Einzelaussagen wahr sind. Dies entspricht dem üblichen Sprachgebrauch.

5.15.2. Die Disjunktion: or

Abb. 50: Wahrheitstabelle or

Die Verknüpfung zweier logischer Aussagen mit or ergibt eine neue logische Aussage, die nur dann falsch ist, wenn beide Einzelaussagen falsch sind. Wenn entweder die eine oder die andere oder beide Aussagen wahr sind, wird die Gesamtaussage ebenfalls wahr. Eine gewisse Aufmerksamkeit ist angebracht, da das or durch die dritte Kombinationsmöglichkeit (beides wahr) nicht dem in Konversationen üblichen unterscheidenden Sprachgebrauch des Wortes „oder“ entspricht.

5.15.3. Die Negation: not Der Wahrheitswert einer logischen Aussage wird durch Voranstellen von not negiert. Der Ausdruck not True ergibt False und umgekehrt. Vorsicht: das entspricht ganz und gar nicht dem in Mensch-Mensch-Konversationen bei Fragen üblichen Sprachgebrauch!

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

58

„Willst Du kein Eis?“ – „ja, logisch!“ (Logische Konsequenz: kein Eis. Die logisch richtige Antwort für ein Eis wäre „nein“ gewesen. Ein logisches „doch“ gibt es nicht). Auch zusammengesetzte logische Ausdrücke lassen sich negieren. Dabei verändern sich jedoch gelegentlich die Operatoren. Wenn A und B zwei Aussagen oder Wahrheitswerte sind, so gilt: not (A and B) ist äquivalent zu not A or not B not (A or B) ist äquivalent zu not A and not B

5.15.4. Die Kontravalenz: ^

Abb. 51: Wahrheitstabelle ^

Die Kontravalenz oder exklusiv-oder-Verknüpfung ergibt immer dann den Wert True, wenn entweder die eine oder die andere Aussage wahr ist, aber nicht beide gleichzeitig. Diese in der Boole’schen Algebra eher seltene logische Verknüpfung wird in anderen Programmiersprachen oft mit dem Operator xor vorgenommen. In Python ist dazu das Zirkumflex ^ vorgesehen, das wiederum anderenorts üblicherweise als Potenzierungsoperator verwendet wird1.

5.15.5. Prioritäten Wie in der „Zahlenalgebra“ haben auch in der Boole’schen Algebra die einzelnen Operatoren unterschiedliche Prioritäten. Bei zusammengesetzten logischen Ausdrücken hat not die höchste, and eine mittlere und or die geringste Priorität. Im Zweifelsfall empfiehlt es sich stets, Klammern zu verwenden.

5.15.6. Umkehrung logischer Aussagen Bei der Umkehrung logischer Aussagen ist Vorsicht geboten. So lautet die Negierung von a and b nicht etwa not a and not b oder gar not a 1 Mir gefällt diese Verwechslungsgefahr auch nicht. Das ganze Kapitel 5.15.4 ist eigentlich nur dazu da, um auf dieses ärgerliche Problem hinzuweisen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

59

and b, sondern not a or not b. Wer sich da unsicher fühlt, sollte besser Klammern verwenden und not(a and b) schreiben.

5.15.7. Boolesche Variablen Wahrheitswerte können in Python in Variablen gespeichert werden. Diese Variablen, die entweder den Wert True oder den Wert False haben, nennt man boolesche Variablen.

Abb. 52: Boole’sche Variablen

Beachten Sie in der Abbildung rechts bitte den Unterschied zwischen dem Zuweisungsoperator = („wird zu“) und dem Vergleichsoperator == („ist gleich“)! Der Variable B wird der Wahrheitswert der Aussage 7 == 7, also True, zugewiesen.

5.16. Venn-Diagramme John Venn, ein Mathematiker an der Universität zu Cambridge, stellte 1880 eine Diagrammform vor, mit der sich auf sehr übersichtliche Weise logische Aussagen formulieren und überprüfen lassen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

60

Im

einfachsten

Fall

bestehen

Venn-Diagramme aus zwei sich überschneidenden Kreisen A und B, die jeweils einer Logischen Aussage zugeordnet sind. Alle Elemente, auf die Aussage A zutrifft, werden in Kreis A versammelt und alle Elemente, auf die Aussage B zutrifft, finden wir in Kreis B wieder. Im Schnittbereich sollten nur diejenigen Elemente zu finden sein, auf die sowohl Aussage A als auch Aussage B zutrifft. In einem Pythonprogramm würde für diese Schnittmenge gelten: A and B == True. Die folgende Abbildung zeigt einige

ausgewählte

Möglichkeiten,

Logische Aussagen zu den Mengen A und B zu formulieren, um exakt eine bestimmte Teilmenge zu erhalten.

Abb. 53: Das John-Venn-Fenster in Cambridge (CC-by-SA, Schutz)

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

61

Abb. 54: Venn-Diagramme und Logische Aussagen

5.17. Fallunterscheidungen: if … elif …else Mit dem Schlüsselwort if können wir eine logische Aussage dazu nutzen, den Programmlauf zu beeinflussen. Nur wenn die Aussage wahr ist, wird der darauf folgende Programmblock ausgeführt. Wir sprechen dann auch von einer „bedingten Ausführung“. lies zwei Zahlen a und b

ist b gleich null?

ja

gib Fehlermeldung aus

nein teile a durch b Abb. 55: Bedingte Ausführung

Ein Programmblock besteht aus einer oder mehreren Programmzeilen. In Python wird dieser Programmblock dadurch festgelegt, dass die Zeilen des Blocks eingerückt werden. Üblicherweise beträgt das Maß der Einrückung 4 Leerzeichen. Es sind auch andere Werte möglich, die Einrückung innerhalb eines Blocks muss aber stets einheitlich sein.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

62

Abb. 56: Drei Fallunterscheidungen mit if …

Jede eingegebene Zahl wird nun drei verschiedenen Tests unterzogen. Immer dann, wenn eine der Testbedingungen erfüllt ist, wird ein entsprechender Text ausgegeben. Da nur eine der drei Bedingungen wahr sein kann, gibt das Programm in jedem Durchlauf nur eine der drei Auswertungszeilen auf dem Bildschirm aus.

Abb. 57: Drei Durchläufe des vorigen Programms

Das funktioniert zwar, aber besonders effizient ist unser Programm mit diesen drei if-Abfragen nicht. Selbst, wenn die erste Abfrage positiv beantwortet wird, führt das Programm die zweite Abfrage auch noch aus. Das ist ja eigentlich unnötig. Die dritte Abfrage ist sogar völlig überflüssig, denn wenn die Zahl nicht positiv oder negativ ist, bleibt schließlich nur noch die null übrig. Python verfügt daher über die Möglichkeit, diese Art von Abfragen deutlich eleganter zu gestalten. Mit elif wird eine Abfrage nur dann gestartet, wenn die vorangegangene Abfragebedingung nicht erfüllt wurde. Es können beliebig viele elif-Abfragen hintereinander ausgeführt werden. Ganz am Ende einer Kette von Abfragen können wir schließlich mit else alle übriggebliebenen Fälle einfangen, die bisher nicht berücksichtigt

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

63

wurden. Unser Programmbeispiel formulieren wir nun so:

Abb. 58: Mehrfachauswahl mit if … elif … else

Das sieht im Programmtext nicht viel anders aus als im ersten Programmfragment, doch wenn wir den Programmfluss grafisch darstellen, dann können wir den Unterschied zwischen den beiden Lösungen auf einen Blick erfassen:

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

64

if … if … if

if … elif … else

Lies Zahl z ein

Lies Zahl z ein

z0? "positiv"

"negativ"

nein "positiv"

ja "weder noch" "weder noch"

Ende

Ende

Abb. 59: Vereinfachung des Programmflusses durch geschachtelte Abfragen

5.18. Fehlerbehandlung Um ein Programm nicht dadurch unnötig kompliziert zu machen, dass man alle möglichen Fehler vorherzusagen und durch kunstvoll geschachtelte if-elif-else-Konstruktionen abzufangen versucht, kann man Python auch einfach anweisen, zu versuchen, ein Programmteil auszuführen und sich nur für den Fall, dass das schiefgeht, eine gute Reaktion überlegen. Den Programmblock, dessen Ausführung versucht werden soll, leiten wir dabei mit try: ein (anschließend die Einrückung nicht vergessen!) und den Programmzeilen zur Fehlerbehandlung wird das Schlüsselwort except: vorangestellt. Das könnte für den Versuch, die Wurzel aus dem Quotienten zweier Zahlen auszugeben (was bekanntlich immer dann schiefgeht, wenn der Nenner null oder der Bruch negativ ist), beispielsweise so aussehen wie in der Abbildung rechts. Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

65

Wenn der try-Block ohne Fehler durchläuft, wird der except-Block nicht ausgeführt. Die häufigste Fehlerquelle in einem laufenden Programm ist die

Abb. 60: Fehlerbehandlung

Eingabe von Werten durch den Benutzer. Hier kann von Leereingaben über Texteingaben und falsche Dezimalzeichen bis hin zu völlig unvorhergesehenen Kreativitäten alles mögliche passieren. Das folgende Programmbeispiel fragt daher hartnäckig solange nach, bis es endlich einen gültigen Zahlenwert erhält. Die boole’sche Variable keineZahl bestimmt dabei, wie lange die Schleife1 ausgeführt wird. Sie wird anfangs auf True gesetzt und verändert ihren Wert erst dann zu False, wenn die Umrechnung der Eingabe mittels float() keinen Fehler hervoruft.

Abb. 61: Anwendungsbeispiel für try…except: fehlertolerante Zahleneingabe

Wer eine Neigung zu Tippfehlern hat, sollte bei der Verwendung der hier vorgestellten universellen Fehlerbehandlung besonders vorsichtig sein, da auch Syntaxfehler den except-Block aktivieren. Um das zu vermeiden, gibt es in Python die Möglichkeit, für verschiedene Fehlerarten eigene Fehlerbehandlungsroutinen zu formulieren. Wer nur auf Zahlenumwandlungsfehler testen will, schreibt oben besser except ValueError: anstelle von except: hin. Damit unser Programm auf mehrere Fehlerbedingungen unterschiedlich reagieren kann, ordnen wir mehrere except-Blöcke untereinander an. Der Programmblock nach except

ValueError: behandelt dann eine

misslungene Zahlenumwandlung oder einen verfehlten Definitionsbereich, Nulldivisionen werden im Block nach

except ZeroDivisionEr-

1 Wie Sie die in Kapitel 4.2.4 vorgestellten Schleifen in Python realisieren können, erfahren Sie in Kapitel 5.19 auf Seite 67.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

66

ror: einer Fehlerbehandlung zugeführt und die eingerückten Programmzeilen nach except KeyboardInterrupt: kümmern sich um den Versuch des Anwenders, das laufende Programm mittels Strg-C abzubrechen. Wollen wir mit einem einzigen except-Block mehrere Fehlerbedingungen behandeln, so formulieren wir die Liste der Fehler als Tupel. Um beispielsweise nach beiden oben genannten Rechenfehlern dieselbe Fehlerbehandlung auszuführen, schreiben wir except (ValueError, ZeroDivisionError): Eine Liste mit häufigen Fehlermeldungen finden Sie im Anhang auf Seite 126 dieses Textes.

5.19. Programmschleifen Wenn unser Programm bestimmte Vorgänge wiederholen soll, dann ist es sinnvoll, die Programmbefehle dazu nicht mehrfach hintereinander zu schreiben, sondern nur einmal einen Programmblock zu formulieren, der dann mehrfach ausgeführt wird. In Python bilden wir einen Programmblock dadurch, dass wir ihn einrücken. Diesem Programmblock stellen wir eine Zeile voran, die aussagt, wie oft oder unter welchen Bedingungen der Block wiederholt werden soll. Die gesamte Konstruktion aus einleitender Bedingung und zu wiederholendem Programmblock nennen wir „Programmschleife“. Python kennt zwei Schleifentypen: die bedingte Schleife, bei der die Wiederholung an den Wahrheitsgehalt einer logischen Aussage gebunden ist und die Zählschleife.

5.19.1. Bedingte Schleifen: while Eine bedingte Schleife wiederholt eine Anweisungsfolge solange, wie eine dazugehörige logische Aussage wahr ist. Sie wird mit dem Schlüsselwort while eingeleitet. Als Beispiel diene ein einfacher Countdown-Zähler, der einen Zahlenwert i solange verkleinert, wie dieser größer oder gleich null ist.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

67

Vor der Schleife wird die Zählvariable i auf einen Startwert gesetzt. In der Schleife wird sie bei jedem Durchlauf erneut ausgegeben und anschließend heruntergezählt. Schließlich springt die Programmausführung wieder zur Abfrage oberhalb des eingerückten Programmblocks, um erneut zu entscheiden, ob die Schleife wieder-

Abb. 62: while-Schleife

holt oder verlassen wird. Im Flussdiagramm sieht eine Schleife zuerst wie eine gewöhnliche ifAbfrage aus. Neu ist hier, dass die beiden Zweige nicht wieder unterhalb der Verzweigung zusammengeführt werden, sondern dass nach Abarbeitung des Schleifenblocks wieder zur Abfrage zurückgesprungen wird. setze i zu 3

ist i≥0?

ja

gib i aus

nein verkleinere i um 1 weiter im Programm… Abb. 63: Flussdiagramm einer while-Schleife

Damit die Schleife jemals wieder verlassen wird, muss innerhalb des zu wiederholenden Programmblocks der Wahrheitswert der logischen Aussage in der einleitenden Abfrage geändert werden. Hängt diese Aussage allein von i ab, ist also der Wert von i zu ändern. Geschieht dies nicht, läuft die Schleife endlos weiter.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

68

Mit der Tastenkombination Strg-C lässt sich ein Python-Programm, das in eine Endlosschleife geraten ist, abbrechen.

5.19.2. Aussprung mit break Im Gegensatz zu anderen Programmiersprachen, die zwischen abweisenden (solange, wie etwas gilt, wiederhole …) und nicht abweisenden (wiederhole … bis etwas gilt) Schleifen unterscheidet, gibt es in Python nur einen einzigen bedingten Schleifentyp. Die Konsequenz daraus scheint zu sein, dass wir alle Algorithmen vom Typ „wiederhole etwas, bis eine Bedingung erfüllt ist“ so umformulieren müssen, dass sie als „solange wie eine Bedingung erfüllt ist, wiederhole etwas“ gelesen werden können. Aus der Formulierung „erhöhe den Wert, bis er doppelt so hoch wie der Ursprungswert ist“ wird dann „solange der Wert nicht doppelt so hoch wie der Ursprungswert ist, erhöhe ihn“. Wir können aber auch einen Trick anwenden, um das Problem zu umgehen. Python erlaubt es, eine Schleife jederzeit zu verlassen, indem das Schlüsselwort break verwendet wird. Kombinieren wir nun eine while-Schleife, die als Endlosschleife ausgebildet wird (indem die Wiederholungsbedingung fest auf True gesetzt wird) mit einer if-Abfrage am Ende der Schleife, die bei Erfüllung die Schleife mittels break verlässt, so können wir auch in Python nichtabweisende Schleifen programmieren.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

69

Abb. 64: Nicht abweisende Schleife

Die ungewöhnliche Formulierung while True: spiegelt sich im obigen Flussdiagramm in der kuriosen Verzweigung „für immer“ wider, die nur einen einzigen Ausgang anstelle der üblichen zwei hat. Häufig wird stattdessen auch nur ein kleiner Kreis als Diagrammsymbol verwendet, der besagen soll, dass sich hier mehrere zuvor verzweigte Programmlaufpfade wieder vereinigen. Ein klassischer Anwendungsfall dieser Konstruktion ist beispielsweise die wiederholte Ausführung einer Berechnung. Nach Abschluss eines Rechendurchgangs soll der Anwender gefragt werden, ob ein weiterer Durchlauf des Programms gewünscht ist. Wird die Frage mit n für „nein“ beantwortet, verlässt das Programm die Endlosschleife mittels break und beendet entweder seine Ausführung nach der Schleife oder beginnt anschließend mit einer anderen Aufgabe.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

70

Abb. 65: Die while-True-…-break-Kombination

Stilvoller und meistens auch besser lesbar ist es allerdings, eine sauber formulierte Wiederholungsbedingung an den Anfang der Schleife zu setzen. Das Verlassen einer Schleife mit break sollte die Ausnahme bleiben. Zum Vergleich hier ein ähnliches Programm, aber diesmal sauber formuliert ohne break und Endlosschleife. Nun ist ist zwar eine Hilfsvariable (Berechnung_erwünscht) notwendig, die zuerst einmal auf True gesetzt werden muss, damit die Schleife überhaupt betreten werden kann, das Programm wirkt jedoch aufgeräumter und lesbarer:

Abb. 66: while-Schleife mit Boole’scher Hilfsvariable

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

71

5.19.3. Iterative Schleifen: for Eine Spezialität von Python ist die Iterationsschleife. Sie wiederholt einen Programmblock für jedes einzelne Element einer Liste oder eines Iterators (siehe Kapitel 5.19.4 und 5.20). Diese Listenelemente müssen nicht sortiert sein und können sogar verschiedenen Typs sein:

Abb. 67: for-Schleife über unterschiedliche Listenelemente

5.19.4. Der Iterator range() Iteratoren sind eine besondere Python-Spezialität. Man kann sich einen Iterator als eine Art Erzeugungsfunktion vorstellen, die unter anderem dazu eingesetzt werden kann, nacheinander die einzelnen Elemente für eine for-Schleife zu liefern. Dies kann beispielsweise eine Zahlenfolge sein. Der Iterator range() erzeugt solche Zahlenfolgen. Im einfachsten Fall wird er mit der gewünschten Zahl der Folgenelemente als einzigem Parameter aufgerufen.

Der

Aufruf

Abb. 68: Der Iterator range()

range(Grenzwert) erzeugt nacheinander die ganzen Zahlen von null bis Grenzwert-1. Soll die Zahlenfolge nicht bei null beginnen, so geben wir einen Startwert vor: range(Startwert, Grenzwert). Als dritten Parameter können wir schließlich noch eine ganzzahlige Schrittweite angeben, um den Startwert um einen anderen Wert als eins zu erhöhen: range(Startwert, Grenzwert, Schrittweite). Die letzte erzeugte Zahl ist bei positiver Schrittweite immer kleiner als der Grenz-

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

72

wert.

5.19.5. Verschachtelte Schleifen Schleifen dürfen selbstverständlich ebenfalls wieder Schleifen enthalten. Der in Abbildung 69 zu sehende Dreizeiler verwendet zwei ineinander verschachtelte Schleifen.

Abb. 69: Verschachtelte Schleifen

Bei jedem einzelnen Durchlauf der äußeren Schleife (a) werden sämtliche Durchläufe der inneren Schleife (b) erneut ausgeführt.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

73

Im Flussdiagramm lassen sich die Anordnung und der Ablauf der Schleifen mit etwas gutem Willen nachvollziehen. Allerdings sehen wir hier auch, dass die Grenzen der Anschaulichkeit von Flussdiagrammen schnell erreicht sind – selbst wenn diese farbig dargestellt werden (innere Schleife blau, äußere Schleife rot).

Abb. 70: Verschachtelte Schleifen im Flussdiagramm

Wenn es darum geht, strukturierte Algorithmen mit Fallunterscheidungen und Schleifen übersichtlich darzustellen, werden wir darum üblicherweise bevorzugt Struktogramme anstelle von Flussdiagrammen verwenden. Das Struktogramm rechts zeigt

Für a von 0 bis 2 Für b von 0 bis 2

dieselben verschachtelten Schleifen wie das Flussdiagramm oben

Gib a, b und a*b aus

an, ist aber bei Weitem übersichtlicher. Auch die Anzahl der tatsächlich auszuführenden

Abb. 71: Verschachtelte Schleifen im Struktogramm

Schleifendurch-

läufe ist im Struktogramm unmittelbar erkennbar, während sie im Flussdiagramm zuerst zusammengesucht werden muss.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

74

5.20. Listen Listen sind in Python veränderliche Gruppen von Werten, deren Elemente hintereinander („sequenziell“) angeordnet sind und einzeln über einen Index angesprochen werden können.

Abb. 72: Beispiele für Listen

Eine Liste wird in Python durch eckige Klammern dargestellt, zwischen denen sich durch Kommas getrennte Listenelemente befinden. Die Elemente von Listen dürfen selbst wieder Listen sein. Dadurch können sie sehr komfortabel für Rechnungen mit Vektoren und Matrizen eingesetzt werden. Siehe Kapitel 5.21 und 5.22.

5.20.1. Tupel Tupel sind eine Sonderform von Listen. Ein Tupel kann grundsätzlich wie eine Liste verwendet werden, ist im Gegensatz zu dieser aber unveränderlich. Geschrieben werden Tupel als kommagetrennte Werte in runden Klammern. Liste = [1, 2, 3] Tupel = (1, 2, 3)

5.20.2. Listenidizes Die Indexierung der Listenelemente beginnt bei null. Eine Liste L mit zehn Elementen besteht also aus den Elementen L[0] bis L[9].

Abb. 73: Indizierung von Listenelementen

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

75

Python erlaubt auch negative Listenindizes. Sie dienen dazu, auf einfache Art und Weise auf die hinteren Elemente einer Liste zuzugreifen. L[-1] ist dabei das letzte Element der Liste L, L[-2] das vorletzte und so weiter.

5.20.3. Listenabschnitte (Slices) Kopien einzelner Abschnitte einer Liste (oder eines Tupels) nennt man „Slices“. Man erzeugt sie, indem man anstelle einer einzelnen Indexzahl einen Bereich [von:bis] angibt. Die Angabe bis ist dabei der Indexwert des ersten Elementes, das nicht mehr zum Slice gehört. Slices enthalten standardmäßig aufeinanderfolgende Elemente, es ist aber auch die Angabe einer Schrittweite erlaubt: L [ von : bis : Schrittweite ] Jede der drei Angaben dürfen wir weglassen. Anstelle von von wird dann 0 verwendet, anstelle von bis wird len(L) angenommen und die Schrittweite ist standardmäßig auf 1 gesetzt. Der Ausdruck L[:] erzeugt eine vollständige Kopie der Liste L.

Abb. 74: Tupelabschnitte am Beispiel von Monatsnamen

5.20.4. Kopieren einer Liste Im Gegensatz zu einfachen Datentypen wie Ganzzahlen oder Zeichenketten werden Listen intern immer nur als Verweis auf einen Speicherbereich behandelt, an dem die eigentlichen Inhalte liegen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

76

Das erhöht zwar die Verarbeitungsgeschwindigkeit von Python sehr, führt aber zu dem unerwarteten Phänomen, dass eine Zuweisung einer Liste zu einer Variablen keine neue unabhängige Liste erzeugt, sondern nur einen Aliasnamen für die bereits vorhandene Liste. Um wirklich unabhängige Kopien zu erhalten, sollten die im vorigen Kapitel

vorgestellen

Listenab-

Abb. 75: Liste: Kopie und Alias

schnitte verwendet werden.

5.20.5. Umwandlung eines Iterators in eine Liste Mit der Funktion list() lassen sich die von einem Iterator erzeugten Elemente zu einer Liste

Abb. 76: Vom Iterator zur Liste

zusammenfassen.

5.20.6. Listenerzeugung (List Comprehension) Python kennt eine funktionale Art, Listen zu erzeugen, die ungeheuer effizient ist. Dazu wird einem Ausdruck, das kann zum Beispiel ein Variablenname oder eine Berechnung sein, eine Schleife zugeordnet. Das Resultat ist eine Liste, die aus den bei den einzelnen Schleifendurchläufen ausgewerteten Ausdrücken besteht. Zusätzlich

zur

obligatorischen

Schleife kann zusätzlich noch eine

Abb. 77: Listenerzeugung – List Comprehension

Auswahlbedingung formuliert werden. Die Liste erhält dann nur diejenigen Werte, bei denen die angegebene Bedingung erfüllt ist.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

77

Wollen wir beispielsweise eine Liste aller natürlichen Zahlen kleiner als 20 erzeugen, die weder durch 2 noch durch 3 teilbar 1 sind, so schreiben wir: [i for i in range(20) if i%2 and i%3] Heraus kommt: [1, 5, 7, 11, 13, 17, 19] Pythons Schreibweise zur Erzeugung von Listen kommt der mathematische Notation von Mengen sehr nahe. In der Mathematik definiert man die

Quadratzahlen

der

natürlichen

Zahlen

beispielsweise

als

{x² | x ∈ ℕ} und in Python als [x**2 for x in N] – wobei N hier eine bereits vorhandene (endliche!) Liste von Zahlen sein muss, die sich zum Beispiel so erzeugen lässt: N = [n for n in range(1000)].

5.20.7. Listenelemente als Einzelparameter Wenn wir Listen als Parameter an eine Funktion übergeben, so erhält die Funktion die Liste „am Stück“ und muss sich selbst um die Aufteilung der Listenelemente kümmern.

Abb. 78: Der Asterisk * zerlegt die Liste in Einzelelemente

Wir können aber auch dem Listennamen ein Sternchen („*“, auch Asterisk2 genannt) voranstellen – dann werden der Funktion die einzelnen Listenelemente so übergeben, als seien sie beim Aufruf der Funktion einzeln, als mit Kommas getrennte Parameter, geschrieben worden. 1 Den zur Feststellung der Teilbarkeit verwendeten Modulo-Operator haben wir in Kapitel 5.11 auf Seite 52 kennengelernt – falls nicht, schauen Sie dort schnell mal nach. 2 So ähnlich wie der tapfere kleine Gallier Asterix. Dessen Name leitet sich vom französischen „Astérisque“ ab, welches ebenfalls „Sternchen“ bedeutet. Es gibt auch ein Zeichen, das Obelisk heißt: „†“ oder "\u2020". Das hat in Python aber keine spezielle Bedeutung und es sieht auch gar nicht wie ein Hinkelstein aus.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

78

5.20.8. Funktionen für Tupel und Listen Auf Listen und Tupel können wir eine Reihe von nützlichen Standardfunktionen anwenden. Die in der folgenden Tabelle aufgeführten Funktionen liefern die beschriebenen Rückgabewerte, wenn ihnen als Argument eine Liste oder ein Tupel (LoT) übergeben wird: Funktion

Rückgabewert

len(LoT)

Anzahl der Elemente

sum(LoT)

Summe der Elemente

min(LoT)

Kleinstes Element

max(LoT)

Größtes Element

sorted(LoT)

neue Liste in sortierter Form

all(LoT)

True, wenn alle Elemente True

any(LoT)

True, wenn irgendein Element True

5.20.9. Methoden von Listen Es gibt Funktionen in Python, die wir speziell auf Listen anwenden können. Solche Funktionen, die nur für bestimmte Objekte anwendbar sind, nennt man „Methoden dieses Objekts“. Sie werden mit der Schreibweise Objektname.Methodenname(Argumente) aufgerufen. In der folgenden Tabelle sind einige Methoden aufgeführt, die uns die Arbeit mit Listen sehr vereinfachen können. Methode und Beschreibung

Anwendungsbeispiel

.append(Element) Hängt ein Element an eine Liste an. .remove(Element) Löscht das erste Vorkommen eines Elements aus einer Liste.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

79

Methode und Beschreibung

Anwendungsbeispiel

.index(Element) Gibt die Position der ersten Fundstelle eines Elements aus. Enthält die Liste das Element nicht, tritt ein Fehler vom Typ ValueError auf. .count(Element) Zählt, wie oft ein bestimmtes Element in einer Liste vorkommt. .reverse() Kehrt die Reihenfolge einer Liste um. .sort() Sortiert die Elemente einer Liste. Die Listenelemente müssen alle vom selben Typ sein. Die Methoden .index() und .count() sind hierbei die einzigen, die auch auf Tupel angewendet werden können.

5.21. Vektoren Vektoren können in Python ganz einfach als Listen von Zahlenwerten dargestellt werden. Anstelle der mathematischen Notation …

1 ⃗ a= 2 3 4

()

… schreiben wir in Python: a = [1, 2, 3, 4]

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

80

5.21.1. Vektoraddition ⃗ c =⃗ a+ ⃗ b Um Vektoren zu addieren, benötigen wir eine Schleife, die nacheinander alle Elemente zweier Listen (die Summandenvektoren) addiert und daraus eine dritte Liste (den Summenvektor) zusammensetzt. Angenommen, wir haben die Listen A und B, die jeweils 5 Elemente aufweisen. Um eine neue Liste C zu erhalten, könnten wir zunächst eine leere Liste anlegen … C = [] … und anschließend schrittweise die Summe der fünf Listenelemente A[0]+B[0] bis A[4]+B[4] als neues Listenelement (daher mit eckigen Klammern umschlossen) an die im Verlauf der Abarbeitung immer länger werdende Liste C anhängen.

Abb. 79: Vektoraddition mit einer klassischen Zählschleife

Dies wäre die klassische Vorgehensweise in den meisten Programmiersprachen. In Python geht es eleganter, kürzer und übersichtlicher, indem die Berechnung der Liste C mittels der funktionalen Listenerzeugung 1 vorgenommen wird: C = [A[i]+B[i] for i in range(5)]

1 Die Funktionale Listenerzeugung wird auch List Comprehension (LC) genannt. Siehe Kapitel 5.20.6.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

81

Die Variable i nimmt dabei nacheinander alle fünf Werte von 0 bis 4 an. Für beliebig lange (aber gleichlange) Listen A und B sieht die funktionale Listenerzeugung so aus: C = [A[i]+B[i] for i in range(len(A))]

5.21.2. Skalarprodukt Das Skalarprodukt zweier Vektoren ist die Summe der Produkte ihrer korrespondierenden Elemente. Auch diese Berechnung können wir

entweder

als

klassische

Schleife formulieren, indem eine

Abb. 80: Skalarprodukt mit einer klassischen Zählschleife

vor der Schleife auf null gesetzte

Summe schrittweise um das Produkt der einzelnen Listenelemente erhöht bzw. verringert wird, oder wir geben abermals der funktionalen Listenerzeugung den Vorzug, indem wir zunächst eine Liste aus allen Einzelprodukten generieren und anschließend die Summe derer Elemente über Pythons eingebaute Funktion sum() ermitteln: SP = sum([A[i]*B[i] for i in range(5)])

5.21.3. Formatierte Ausgabe eines Vektors Mit der in Kapitel 5.26.3 auf Seite 103 vorgestellten formatierten Zahlenausgabe mit Platzhaltern können wir die einzelnen Zahlenwerte eines Vektors gut lesbar geordnet untereinander ausgeben. Die Funktion rechts gibt die Elemente eines als Argument übergebenen Vektors

mit

jeweils

4

Nachkomma–stellen und 10 Stellen Gesamtbreite untereinander aus.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

Abb. 81: Formatierte Ausgabe eines Vektors

82

Abb. 82: Aufruf der neuen Funktion druckeVektor()

5.22. Matrizen Eine Matrix lässt sich in Python als Liste von Zeilenvektoren darstellen, welche selbst jeweils Listen von einzelnen Zahlenwerten sind.

(

1 2 3 4 5 6 7 8 A= 9 10 11 12 13 14 15 16

)

Abb. 83: Matrix in mathematischer Notation und in Python-Schreibweise

Die Elemente der Matrix werden in der Form Matrixname[Zeile][Spalte] adressiert. Die Nummerierung der Indexpositionen beginnt wie bei allen Listen mit der Null. Die Eins oben links in Abbildung 83 wäre dann als A[0][0] anzusprechen und die Sieben in der zweiten Zeile und dritten Spalte als A[1][2]. Bei der Erzeugung und Verarbeitung von Matrizen gehen wir prinzipiell genauso vor wie bei einfachen Listen – mit dem Unterschied, dass wir

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

83

nun mit verschachtelten Schleifen über die Spalten und Zeilen der Matrix arbeiten. Das wird schnell deutlich, wenn wir zwei besondere Matrizen erzeugen, die Nullmatrix und die Einheitsmatrix.

5.22.1. Nullmatrix Die Nullmatrix ist eine Matrix, bei der alle Elemente den Wert null haben. Eine Nullmatrix A mit 5 Spalten und 4 Zeilen sieht so aus:

(

0 0 A= 0 0

0 0 0 0

0 0 0 0

0 0 0 0

0 0 0 0

)

In Python wäre dies also eine Liste aus vier anderen Listen, die jeweils 5 Nullen enthalten: A = [ [0 for s in range(5)] for z in range(4)]

5.22.2. Einheitsmatrix Die Einheitsmatrix ist eine quadratische Matrix, bei der die Elemente der Hauptdiagonale den Wert 1 und die restlichen Elemente den Wert 0 haben. Eine Einheitsmatrix können wir in Python beispielsweise folgendermaßen funktional erzeugen:

Abb. 84: Funktionale Erzeugung der Einheitsmatrix

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

84

5.22.3. Größe einer Matrix ermitteln Wenn

wir

die

Python-Funktion

len() auf eine Matrix anwenden, dann erhalten wir zunächst nur die Zahl der Zeilenvektoren, also die Zeilenzahl der Matrix. Um auch die Spaltenzahl zu ermitteln, fragen wir die Länge eines beliebigen Zeilenvektors ab. Im Beispiel in Abbildung 85 ist A

Abb. 85: Zeilen- und Spaltenzahl einer Matrix

die zu untersuchende Matrix mit zwei Zeilen und drei Spalten und A[0] ist die erste Zeile dieser Matrix.

5.22.4. Matrizen kopieren Beim Kopieren von Matrizen haben wir ein ähnliches Problem wie bei einzelnen Listen. Auch hier legt Python bei einfachen Zuweisungen lediglich Aliasnamen an, die jeweils auf denselben Inhalt verweisen. Die bei einfachen Listen anwendbare Verwendung von Slices hilft zunächst nicht weiter, da die einzelnen Elemente einer Matrix ja auch wieder Listen sind, die nicht direkt kopiert werden können. Ein denkbarer darin,

die

Ausweg besteht

Matrixkopie

mittels

funktionaler Listenerzeugung aufzubauen, indem sie aus echten Ko-

Abb. 86: Kopieren von Matrizen

pien der einzelnen Zeilen zusammengesetzt wird. Einfacher ist jedoch die Verwendung der Funktion deepcopy() aus dem Modul copy. Nach ihrem Import mittels from copy import deepcopy er-

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

85

zeugt die Funktion von jeder Matrix beim Aufruf deepcopy(Matrixname) eine unabhängige Kopie.

5.22.5. Matrizen transponieren Als „Transponieren“ bezeichnet man das Vertauschen der Zeilen- und Spaltenzuordnung einer Matrix. Aus einer 2×3-Matrix wird beispielsweise eine 3×2-Matrix und aus einem Zeilenvektor wird ein Spaltenvektor.

Abb. 87: Transponieren einer Matrix

5.22.6. Matrizen addieren Es gibt Erweiterungen für Python wie NumPy und SciPy 1, mit denen numerische Berechnungen mit großen Datenmengen sehr einfach gestaltet werden können und mit hoher Geschwindigkeit ausgeführt werden können. Mit wenig Aufwand lassen sich Routinen für einfache Matrizenrechnungen aber auch selbst programmieren. In den folgenden Kapiteln zeigen wir das am Beispiel einiger Matrizenoperationen. Beginnen wir einmal mit der Matrizenaddition. Zwei gleich große Matrizen werden addiert, indem alle korrespondierenden Elemente der beiden Matrizen addiert werden:

(

)(

)(

1 2 3 10 20 30 11 22 33 4 5 6 + 40 50 60 = 44 55 66 7 8 9 70 80 90 77 88 99

)

Ganz analog zur Vektoraddition erfolgt die Matrizenaddition in Python entweder explizit mittels zweier verschachtelter Schleifen oder mittels funktionaler Listenerzeugung. 1 Download von http://numpy.scipy.org/, deutsche Anleitung auf http://www.python-kurs.eu/numpy.php

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

86

Wählen wir die Methode mit zwei klassischen verschachtelten Schleifen, so können wir für die Summe C zunächst eine Nullmatrix vorsehen. Dieser zusätzliche Schritt erspart es uns hier, die Matrix C Stück für Stück zusammenzusetzen, wie wir es mit dem Summenvektor in Kapitel 5.21.1 gemacht haben. Stattdessen schreiben wir die berechneten Werte direkt in die bereits vorhandenen Matrixelemente.

Abb. 88: Matrizenaddition mit vorbelegter Zielmatrix

Kürzer geht es wieder mit der funktionalen Listenerzeugung, für die wir natürlich auch keine zusätzliche Nullmatrix anlegen müssen: C = [ [A[j][i]+B[j][i] for i in range(3)] for j in range(3)]

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

87

5.22.7. Matrizen multiplizieren Zwei Matrizen werden multipliziert, indem die Summe der Produkte aus ihren korrespondierenden Elementen gebildet wird. Die Spaltenzahl der ersten Matrix muss der Zeilenzahl der zweiten Matrix entsprechen.

B ↓„mal “ →

A

[

[ ][ 10 20 30 40 50 60

1 4

2 5

3 6

10⋅1+ 20⋅4 10⋅2+ 20⋅5 10⋅3+ 20⋅6 30⋅1+ 40⋅4 30⋅2+ 40⋅5 30⋅3+ 40⋅6 50⋅1+ 60⋅4 50⋅2+ 60⋅5 50⋅3+ 60⋅6

]

]

C Abb. 89: Beispiel für eine Matrizenmultiplikation

Um eine allgemeine Lösung zu programmieren, die für beliebig große Matrizen funktioniert (vorausgesetzt natürlich, die Größen der beiden Matrizen passen zusammen), überlegen wir uns folgenden Algorithmus: Wir gehen zeilenweise durch Matrix A und für jede Zeile von A gehen wir spaltenweise durch Matrix B. Für jede Spalte von B wie-

Abb. 90: Struktogramm zur Matrizenmultiplikation

derum bilden wir die Summe der Produkte der einzelnen Elemente der gerade betrachteten Zeile von A und Spalte von B. Dazu setzen wir die Summe in jedem Durchlauf zunächst auf null und erhöhen sie in einer dritten Schleife, die über die Spalten von A in der gerade betrachteten Zeile (und gleichzeitig über die Zeilen von B in der gerade betrachteten Spalte) läuft, um das jeweilige Produkt der beiden ausgewählten Elemente.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

88

Eine Umsetzung des Algorithmus innerhalb eines Pythonprogrammes könnte dann so aussehen (hier mit dem Umweg über eine zuvor erzeugte Nullmatrix zur leichten Aufsummierung der Ergebniskoeffizienten):

Abb. 91: Pythonprogramm zur Matrizenmultiplikation

Mit diesem Algorithmus können wir auch Matrix-Vektor-Multiplikationen berechnen. B ist dann der Sonderfall einer Matrix mit nur einer Spalte. Wir müssen dann jedoch darauf achten, dass B als Spaltenvektor vorliegen muss, nicht als Zeilenvektor. Anstelle von B = [1,2,3] muss es also heißen B = [[1],[2],[3]]

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

89

Gegebenenfalls muss B zuerst transponiert werden.

5.22.8. Matrix mit Vektor multiplizieren Das Transponieren des Vektors von der Spaltenform in die Zeilenform können wir uns sparen, wenn wir unser Programm auf diesen Sonderfall abstimmen. Die Multiplikation einer Matrix mit einem Vektor sieht dann so aus wie in dem folgenden Quelltext. Hier wurde zusätzlich etwas eleganter gearbeitet, indem der Lösungsvektor unter Verwendung der funktionalen Schreibweise erzeugt wird. Wir sparen uns so das Anlegen einer Nullmatrix:

Abb. 92: Matrix-Vektor-Multiplikation

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

90

5.22.9. Matrix invertieren Die Inverse oder Kehrmatrix A⁻¹ einer quadratischen Matrix A ist diejenige Matrix, welche mit A multipliziert die Einheitsmatrix ergibt. Der Schweizer Mathematiker Stiefel1 entwickelte einen Algorithmus, mit dem sich eine Matrix A in ihre eigene Inverse umwandeln lässt. Nach ihm wurde dieser Algorithmus Stiefel-Verfahren genannt. Das folgende Struktogramm gibt den Algorithmus dazu wieder. Die Zeilen- und Spaltenzahl der Matrix heißt hier n.

Abb. 93: Struktogramm des Stiefel-Algorithmus

1 Eduard Ludwig Stiefel, * 21. April 1909 in Zürich; † 25. November 1978 ebenda

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

91

5.22.10.

Anwendungsbeispiel: Gleichungslöser

Große lineare Gleichungssysteme zu lösen ist eine häufige Aufgabe im Bauingenieurwesen. Das folgende Programmbeispiel kombiniert die Möglichkeiten der Matrizenberechnung, die wir in den vorangegangenen Kapiteln kennengelernt haben. Um das Programm einfach zu halten, wird kein besonderer Wert auf eine komfortable Ein- oder Ausgabe gelegt. Die Eingangswerte stehen als Konstanten im Programmtext und der Lösungsvektor wird ohne Formatierung ausgegeben.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

92

Abb. 94: Gleichungssysteme mit 100 Unbekannten sind kein Problem mehr.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

93

Einen Wermutstropfen hat diese Lösung: Wenn unser Programm noch länger wird, verringert sich dessen Lesbarkeit zusehends. Schön wäre es dagegen, wenn wir den einzelnen Abschnitten des Programms Namen geben könnten und das Hauptprogramm dann nicht mehr aus einer Unzahl durch Kommentare getrennter Programmzeilen bestünde, sondern nur noch aus den Abschnitten Lies_A_ein, Lies_c_ein, Invertiere_A, Multipliziere_A_mit_c_zu_x und Gib_x_aus, so dass wir ein beinahe selbsterklärendes Programm erhielten. Python unterstützt solch eine Ordnung im Programm durch die Möglichkeit, eigene Funktionen zu definieren.

5.23. Eigene Funktionen definieren In einem Programm mehrmals benutzte Formeln oder Programmteile können wir als Funktion definieren. Im einfachsten Fall nimmt eine Funktion eine beliebige Anzahl von Eingangswerten an und

Abb. 95: Funktionsdefinition und Aufruf mit Rückgabewert

gibt ein davon abhängiges Ergebnis zurück. Die Funktionsdefinition erfolgt durch das Schlüsselwort def, gefolgt vom Funktionsnamen, einem Klammerpaar und einem Doppelpunkt. Das Klammerpaar enthält eine Reihe von nur innerhalb der Funktion sichtbaren Variablennamen, in denen für die Dauer der Ausführung der Funktion deren Eingangswerte gespeichert sind. Auf die Funktionsdefinition folgt der eingerückte Funktionsblock, der mit dem Schlüsselwort return und den zurückzugebenden Werten abgeschlossen wird. Die Funktion addiere(a,b) in Abbildung 95

nimmt genau zwei Werte

entgegen, nennt diese a und b und gibt das Ergebnis der Addition dieser beiden Werte zurück. In Python müssen wir uns keine besonderen Gedanken über die Typen der Eingangsvariablen ma-

Abb. 96: Typenunabhängigkeit

chen. Solange die mit den übergebenen Werten durchgeführten Operatio-

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

94

nen gültig sind, können wir beliebige Datentypen an die Funktion übergeben. Unsere Additionsfunktion funktioniert, wie man sieht, sowohl mit Zahlenwerten als auch mit Zeichenketten. Ein einmal definierte Funktion kann immer wieder aufgerufen werden, indem im Programmtext ihr Name, gefolgt von den jeweiligen Eingangswerten in Klammern, verwendet wird.

5.23.1. Eingangswerte (Argumente) Alle Eingangswerte, die nur mit ihrem Namen in der Funktionsdefinition aufgeführt werden, müssen beim Aufruf einer Funktion angegeben werden. Fehlen ein oder mehrere dieser auch „Argumente“ oder „Parameter“ genannten Werte, gibt Python eine Fehlermeldung aus.

Abb. 97: Die Anzahl der Argumente muss stimmen

5.23.2. Vorbelegte Eingangswerte Eingangswerte

einer

Funktion

können mit einem Standardwert vorbelegt werden. Beim Aufruf der Funktion dürfen diese vorbelegten Werte von der rechten Seite beginnend weggelassen werden. Im

gezeigten

Beispiel

werden

beim ersten Aufruf alle drei Funktionsvariablen

verwendet,

im

zweiten Aufruf nur a und b (c

Abb. 98: Vorbelegte Argumente sind optional

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

95

bleibt auf null), im dritten Aufruf nur a und im vierten Aufruf wird überhaupt kein Parameter übergeben – alle drei Eingangswerte der Funktion bleiben auf ihrer Voreinstellung null.

5.23.3. Beliebig viele Eingangswerte Wenn wir dem letzten (oder einzigen) Parameternamen in der Funktionsdefinition ein Sternchen * voranstellen, so wird der Funktion eine Liste mit beliebig vielen Werten übergeben. Innerhalb der Funktion kann diese Liste beispielsweise mittels einer Schleife Element für Element abgearbeitet werden

Abb. 99: Übergabe von multiplen Argumenten als Liste

Die Funktion list() in der vorletzten Zeile dieses Beispiels wird in Kapitel 5.20.5 auf Seite 77 kurz erklärt. Das ihr vorangestellte Sternchen beim Aufruf der Funktion ist das Gegenstück zum Sternchen innerhalb der Funktion. Beim Aufruf zerlegt es eine Liste in Einzelparameter, wogegen es innerhalb der Funktion Einzelparameter zu einer Liste vereint.

5.24. Sichtbarkeit von Variablen (…)

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

96

5.25. Eigene Module Wollen wir unsere selbstgeschriebene Funktionen in verschiedenen Programmen einsetzen, so ist es nicht nötig, diese immer wieder in den Quelltext neuer Programme hineinzukopieren. Es genügt stattdessen, die Python-Datei, in der sich die gewünschte Funktionsdefinition befindet, als Modul in das neue Programm einzubinden. Angenommen, wir haben soviel Gefallen an unserer Funktion addiere() gefunden, dass wir sie zukünftig immer wieder verwenden wollen. Zusätzlich

sollen

außerdem

noch

die

Funktionen

subtrahiere(),

multipliziere() und dividiere() zur ständigen Verfügung stehen. Wir schreiben dann einfach alle Funktionsdefinitionen hintereinander in eine Datei, die wir zum Beispiel labermath.py nennen können. Fortan stehen uns in allen neuen Programmen die Funktionen unseres ersten selbstgeschriebenen Pythonmoduls zur Verfügung, sobald wir die Zeile from labermath import * in unser Programm aufgenommen haben.

Abb. 100: Das redefreudige Arithmetikmodul „labermath“

Damit das Betriebssystem unser Modul findet, ist es am einfachsten, es im selben Verzeichnis wie unsere anderen Pythonprogramme abzulegen. Wenn Module in anderen Verzeichnissen liegen, müssen diese der Liste

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

97

der von Python zu durchsuchenden Modulpfade hinzugefügt werden; siehe Kapitel 5.25.1. Obwohl Importanweisungen an nahezu jeder beliebigen Stelle eines Programms stehen dürfen, ist es im Interesse der Lesbarkeit und Übersichtlichkeit des Quelltextes eine gute Idee, sie gesammelt an den Anfang zu setzen. Wenn ein Modul außer Funktionsdefinitionen auch noch einen Ausführungsteil enthält, dann werden die dort aufgeführten Programmbefehle beim Importieren des Moduls ausgeführt.

5.25.1. Modulpfade Ein Python-Interpreter, der einer import-Anweisung begegnet, durchsucht der Reihe nach bestimmte Verzeichnisse: 1. das Verzeichnis des aktuell laufenden Python-Programms 2. alle Modulverzeichnisse der Python-Installation 3. weitere an die Liste sys.path angehängte Verzeichnisse Punkt 1 ist der Grund, warum es eine schlechte Idee ist, ein eigenes Python-Programm etwa math.py zu nennen. Alle anderen Pythonprogramme im selben Verzeichnis werden dann vermutlich ein Problem mit Sinus und Kosinus bekommen. Die Liste der Modulverzeichnisse einer Python-Installation erhalten wir, indem wir uns die Variable path im Modul sys anschauen:

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

98

Abb. 101: Anzeige der Modulverzeichnisse unter Windows XP

5.25.2. Funktionsweiser Import Aus einem Modul können wir entweder alle darin vorhandenen Funktionen auf einen Schlag importieren … from Modulname import * … oder wir beschränken uns beim Import auf einzelne oder mehrere ausgewählte Funktionen. Das ist dann sinnvoll, wenn mehrere Module die gleichen Funktionsnamen verwenden und wir nicht wollen, dass die zuletzt importierten Module unkontrolliert bereits vorhandene Funktionen überschreiben. from Modulname import Funktionsname from Modulname import Funktionsname, Funktionsname_2, … Die importierten Funktionen lassen sich direkt mit ihrem Namen ansprechen: Funktionsname()

Abb. 102: Funktionsweiser Import

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

99

5.25.3. Modulweiser Import Es ist auch möglich, alle Funktionen eines Moduls so zu importieren, dass es dabei nicht zu Namenskonflikten kommt. Dazu verwendet man die Schreibweise import Modulname Nach dem auf diese Weise erfolgten

Modulimport

können

alle

Funktionen des Moduls über die aus ihrem jeweiligen Modulnamen

Abb. 103: Modulweiser Import

und ihrem Funktionsnamen kombinierte Schreibweise Modulname.Funktionsname() angesprochen werden.

5.25.4. Funktionsüberschreibungen Die in Kapitel 5.25.2 angesprochenen Funktionsüberschreibungen können wir auch gezielt einsetzen. Angenommen, wir haben ein Programm, in dem sehr viele trigonometrische Berechnungen in Altgrad ausgeführt werden sollen. Anstatt immer wieder in die für die Funktionen des Moduls math erforderliche Einheit Bogenmaß umzurechnen, definieren wir einen Satz trigonometrischer Funktionen, die diese Umrechnung bereits eingebaut haben und verwenden diese stattdessen. Dazu schreiben wir alle Definitionen in ein neues Modul altgrad.py.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

100

Abb. 104: Das Modul „altgrad.py“

Bei der Verwendung unserer neuen Altgradfunktionen müssen wir anschließend nur darauf achten, dass wir unser neues Modul altgrad erst nach dem Modul math importieren, damit die Überschreibungen wirksam werden.

Abb. 105: Einbindung des Altgrad-Moduls

Der Programmlauf zeigt, dass nun tatsächlich alle Winkelfunktionen mit Altgrad anstelle von Bogenmaß berechnet werden:

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

101

Abb. 106: Programmlauf unter Verwendung des Altgrad-Moduls

5.25.5. Funktionszuweisungen In Python ist es möglich, Funktionen genauso wie Zahlen oder Zeichenketten einer Variablen zuzuweisen. Die Funktion kann dann unter dem Namen der Variablen ausgeführt werden. Umgekehrt ist es auch möglich (wenn auch ziemlich unsinnig), die

Abb. 107: Die Zuweisung der Funktion „print“ zur Variablen „c“ erzeugt die Funktion „c“.

Namen vorhandener Funktionen wie print oder input als Variablennamen für Zahlenwerte oder Zeichenketten einzusetzen. Bei der Zuweisung dürfen keine Klammern hinter dem Funktionsnamen stehen, sonst wird die Funktion ausgeführt und anstelle der Funktion selbst nur ihr Rückgabewert der Variablen links vom Gleichheitszeichen zugewiesen.

5.26. Zeichenketten Zeichenketten sind Sequenzen von Buchstaben, Ziffern, Satz- und Sonderzeichen sowie Steuerzeichen von nahezu beliebiger Länge. Seit Python 3 können Zeichenketten alle weltweit verwendeten Schriftzeichen enthalten.

5.26.1. Anführungszeichen in Zeichenketten Textkonstanten dürfen wahlweise von 'einzelnen' oder "doppelten" Anführungszeichen umgeben werden. Der jeweils andere Anführungszeichentyp darf als gewöhnliches Zeichen im auszugebenden Text enthalten sein:

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

102

print("Conny's Frittenranch") print('Sprich "Freund" und tritt ein!') Wenn derselbe Typ von Anführungszeichen, der auch zur Umgrenzung verwendet wird, in der Zeichenkette enthalten sein soll, dann ist diesen Anführungszeichen jeweils ein Rückwärtsschrägstrich \ voranzustellen: print("Man kann auch \"Backslash\" dazu sagen.")

5.26.2. Mehrzeilige Ausgabe Umschließt man eine Textkonstante mit jeweils drei Anführungszeichen, so darf der Text sich über mehrere Zeilen erstrecken und sowohl 'einzelne' als auch "doppelte" Anführungszeichen enthalten. print(""" US-Maß: 3'8" """) Innerhalb der Anführungszeichen muss (darf) keine Rücksicht auf Pythons Einrückungen genommen werden. Dies macht Programmabschnitte, die mehrzeilige Zeichen-

Abb. 108: Mehrzeilige Ausgabe (Quelle: Wikipedia, ASCII-Art)

kettenkonstanten enthalten, mitunter schwer lesbar, sodass man abwägen sollte, ob man hier lieber der Einfachheit oder besser doch der Übersichtlichkeit den Vorzug gibt.

5.26.3. Formatierung mit Platzhaltern Bei der Ausgabe von Fließkommazahlen stellt man gelegentlich fest, dass 15 Nachkommastellen zwar ganz schön für die Rechengenauigkeit sind, aber nicht unbedingt zur Lesbarkeit von numerischen Ergebnissen beitragen. Um Zahlenwerte mit fester Nachkommastellenzahl auszugeben oder weiterzuverarbeiten, unterstützt Python daher die Formatierung von Zahlenwerten durch Platzhalter in Zeichenketten.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

103

Ungewöhnlicherweise gibt es hier in Python zwei verschiedene Verfahren. Die ältere, zur Funktion printf in der Programmiersprache C kompatible Formatierung ist sehr einfach aufgebaut, soll aber zukünftig nicht mehr unterstützt werden. Stattdessen soll die Zeichenkettenmethode .format() werden.

5.26.4. printf-kompatible Formatierung Die Platzhalter bestehen hier im einfachsten Fall aus einem Kennbuchstaben mit vorangestelltem Prozentzeichen. Der Kennbuchstabe zeigt an, welcher Inhaltstyp eingesetzt werden kann. Übliche Werte sind „i“ für ganze Zahlen (int), „f“ für Gleitkommazahlen (float) und „s“ für Zeichenketten (str). Zwischen Prozentzeichen und Kennbuchstabe kann noch die Breite des zu reservierenden Textbereichs angegeben werden, die Ausrichtung (links oder rechts, mit oder ohne führende Nullen) sowie bei Gleitkommazahlen die Anzahl der Nachkommastellen. Die tatsächlich anstelle der Platzhalter einzusetzenden Werte führen wir in einem Tupel1 auf, das von der Zeichenkette, welche die Formatangaben enthält, wiederum mit einem Prozentzeichen abgesetzt wird.

Abb. 109: Formatierte Ausgabe von Gleitkommazahlen

Wer sich an der Syntax dieser Konstruktion stört, kann auch eine eigene printf-Funktion definieren, die so ähnlich wie in C aufgerufen wird: def printf(Maske,*Werte): print(Maske%(Werte)) Aufrufen lässt diese sich beispielsweise wie folgt:

1 Ein „Tupel“ ist in Python eine Gruppe von durch Kommas getrennten Werten, die von runden Klammern umschlossen ist – siehe Kapitel 5.20.1 auf Seite 75.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

104

Abb. 110: Eine selbstgebaute printf-Funktion

Die folgende Tabelle zeigt einige Möglichkeiten der Formatierung auf. Die einzusetzenden Werte sind hier weggelassen worden, um die Darstellung übersichtlich zu halten. Platzhalter %i, %d

%f

%s

%x, %X

Anwendung

Beispiele

Ergebnis

Ganzzahlen (int)

"|%i|" "|%4i|" "|%-4i|" "|%04i|"

|42| | 42| |42 | |0042|

Gleitkommazahlen (float)

"|%f|" "|%.2f|" "|%6.2f|" "|%06.2f|"

|1.234568| |1.23| | 1.23| |001.23|

Zeichenkette (str)

"|%s|" "|%6s|" "|%-6s|"

|abc| | abc| |abc |

"%x" c0af Ganzzahlen als Hexa"%X" C0AF dezimalzahlen "#%02X%02X%02X" #0707FF

%a

Reduzierung auf ASCII-Zeichen

%c

Unicode-Zeichen aus "%i" Ganzzahl "%c"

65 A

Exponentialdarstellung

1.234568e+08 1.23E+08

%e, %E

"%s" "%a"

"%e" "%.2E"

Größe 'Gr\\xf6\\xdfe'

5.26.5. Die Methode .format() … wird im Wintersemester 2012/13 noch nicht behandelt. Da die printfkompatible Formatierung aber bald nicht mehr von Python unterstützt werden soll, wird es hier in Zukunft ein eigenes Kapitel geben.

5.26.6. Kodierung und Dekodierung (…)

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

105

5.27. Dateiverarbeitung In Kapitel 2.2 haben wir gelernt, dass eine Datei eine Gruppe von Informationen ist, die in einem Verzeichnis eines Dateisystems durch einen eindeutigen Dateinamen identifizierbar ist. Das klingt ungeheuer allgemein und so ist es tatsächlich. Wir können in Dateien alles speichern, was wir an Daten auftreiben können, angefangen von ein paar Textzeilen über Tabellen, Webseiten, Grafiken, Filme, Musik bis hin zu kompletten Festplattenabbildern.

5.27.1. Öffnen und Schließen von Dateien Wenn ein Programm eine Datei lesen oder beschreiben will, so muss diese Aktion beim Betriebssystem angemeldet werden. Wir sagen, die Datei wird „geöffnet“. Analog dazu beschreibt das Verb „schließen“ den Vorgang der Abmeldung von der Bearbeitung einer Datei. Solange eine Datei nicht geschlossen wurde, können wir uns nicht darauf verlassen, dass von unserem Programm geschriebene Daten wirklich in der Datei angekommen sind – möglicherweise sind sie noch in einem Zwischenspeicher, wo sie auf einen günstigen Augenblick warten, um tatsächlich in die Datei zu gelangen. Insbesondere unter Microsoft Windows ist das frühzeitige Schließen einer Datei wichtig, da diese Betriebssystem in der Regel den lesenden Zugriff auf eine Datei verbietet, solange diese noch von einem anderen Programm zum Schreiben geöffnet ist. Die Unterscheidung, ob eine Datei zum Lesen oder zum Schreiben geöffnet wird, nennen wir den Modus der Datei. In Python geschieht das Öffnen einer Datei mit der Funktion open(). Diese verlangt als Argument den Namen der zu öffnenden Datei sowie den Modus, in dem die Datei zu öffnen ist und gibt als Rückgabewert einen sogenannten Dateihandle zurück, den wir einer Variable zuweisen können. Mittels des Dateihandles können wir nach dem Öffnen immer wieder lesend oder schreibend auf die Datei zugreifen. Geschlossen wird die Datei mit der Methode .close() des Dateihandles.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

106

5.27.2. Lesen und Schreiben von Dateien (…)

5.28. Grafik Mit dem Modul „tkinter“ besitzt Python vielfältige Möglichkeiten, Grafiken auf dem Bildschirm auszugeben. Oft ist eine einfache Grafik, die eine technische oder mathematische Problemlösung gut visualisiert, schon alles, was wir benötigen. Im Rahmen dieses Textes können wir nur einen kleinen Streifzug durch die Welt der Grafikprogrammierung unternehmen, um zumindest die Grundlagen dieses interessanten Themenbereiches kennenzulernen. Wir können jedoch auch ganze Anwendungsprogramme mit interaktiven grafischen Benutzeroberflächen in Python programmieren. Das ambitionierteste Projekt dieser Art ist wahrscheinlich das Projekt PythonCAD 1, welches ein zu AutoCAD kompatibles CAD-Programm in Python realisiert, das unter Windows, Linux und Mac OS läuft.

5.28.1. Das Hauptfenster Mit der Funktion Tk() erzeugen wir ein leeres Bildschirmfenster, in dem wir anschließend alle anderen Grafikobjekte anordnen können. Dem Hauptfenster ordnen wir mit der Methode .mainloop() die Hauptschleife des Programms zu. In dieser Schleife werden Tastatureingaben und Mausaktionen abgefragt und an die Objekte im Hauptfenster weitergereicht, damit diese passende Aktionen auslösen können.

1 http://sourceforge.net/projects/pythoncad/

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

107

Abb. 111: Das Tk-Hauptfenster

Das Fenster passt seine Größe automatisch an den Inhalt an, den wir später noch hinzufügen werden, wir können aber auch direkt bei der Erzeugung eine Größe festlegen. Auch den Titel des Fensters können wir bei dieser Gelegenheit von „tk“ auf einen informativeren Wert ändern.

Abb. 112: Tk-Fenster mit festgelegter Größe und Überschrift

Es ist möglich, in einem Python-Programm gleichzeitig mit mehreren Fenstern zu arbeiten. Jedem Fenster wird dazu eine Variable zugeordnet. Beim Erzeugen von Grafikobjekten wird anschließend diese Variable als erster Parameter angegeben, um das Objekt genau diesem Fenster zuzuordnen. Solange ein Python-Programm nur ein einziges Grafikfenster verwendet, ist diese Angabe nicht notwendig. In den folgenden Kapiteln wird daher nicht mehr weiter darauf eingegangen. Der Rahmen des Bildschirmfensters und die Gestaltung der Knöpfe zum Minimieren, Maximieren und Schließen des Fensters werden vom Betriebssystem geliefert. Auf das Aussehen dieser Komponenten haben unsere Programme keinen Einfluss. Auch die Standardschriftarten werden Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

108

in der Regel vom Betriebsystem vorgegeben, daher kann es bei unterschiedlichen Betriebssystemversionen stets zu leichten Abweichungen in der Bildschirmdarstellung kommen. Abbildung 113 zeigt dasselbe Programm unter sechs verschiedenen Betriebssystemversionen.

Oben

ist

Ubuntu

Linux

mit

verschiedenen

Desktopkonfigurationen zu sehen und unten sind die Microsoft-WindowsVersionen Windows 2000, Windows XP und Windows 7 zu sehen.

Abb. 113: Fensterdekorationen verschiedener Betriebssystemversionen

5.28.2. Canvas – die Leinwand Als „Leinwand“ (englisch: canvas) dient uns ein rechteckiger Bereich auf dem Bildschirm, das CanvasObjekt. Um ein Canvas-Objekt zu erzeugen,

rufen

wir

die

Funktion

Canvas() auf und speichern ihren Rückgabewert in einer Variablen.

Abb. 114: Die Leinwand in einem passenden Bildschirmfenster

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

109

Als Argumente der erzeugenden Funktion können wir angeben, wie hoch (height) und wie breit (width) die Leinwand sein soll, welche Hintergrundfarbe (bg) gewünscht ist und, falls notwendig, in welchem Bildschirmfenster sie angeordnet werden soll.

Abb. 115: Erzeugung einer Zeichenfläche in vier Zeilen

Die Methode .pack() ordnet die Zeichenfläche dabei in einem in der Regel zuvor definierten Bildschirmfenster an. Wenn dazu keine Angabe erfolgt ist, wird ein neues Fenster erzeugt, in das die Leinwand genau hineinpasst. Die „Hauptschleife“ .mainloop() verwenden wir hier vorläufig nur, damit sich das Grafikfenster nicht sofort wieder schließt. In Programmen mit grafischen Oberflächen wird hier auf Aktionen der Benutzer gewartet, die dann gegebenenfalls bestimmte Funktionen auslösen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

110

5.28.3. Koordinaten der Canvas

Abb. 116: Das tk-Koordinatensystem

Die Canvas verwendet ein ebenes Koordinatensystem mit dem Nullpunkt in der oberen linken Ecke. Die Standardmaßeinheit ist das Pixel, also der einzelne Bildpunkt auf dem Monitor. Je nach Auflösung des Bildschirms ist ein Pixel etwa zwischen 0,08 und 0,35 Millimetern groß. Nach Pixelzahl skalierte Grafiken können daher stark in der Größe variieren. Um Grafiken unabhängig von der Monitorauflösung darzustellen, können Größenangaben auch in Zentimetern, Millimetern, Zoll (25,4 mm) oder typografischen Punkten (1/72 Zoll, rund 0,35 mm) erfolgen. Den Maßzahlen wird dazu einer der Buchstaben „c“ (cm), „m“ (mm), „i“ (Zoll) oder „p“ (Punkt) angehängt. Damit die Skalierung stimmt, müsste das Betriebssystem allerdings genau wissen, wie groß der angeschlossene Monitor ist. In der Regel weiß es das jedoch entweder gar nicht oder nur in sehr grober Näherung.

5.28.4. Koordinatentransformationen Funktionsgraphen, Karteninformationen und technische Zeichnungen müssen wir in aller Regel skalieren, damit sie auf dem Bildschirm in angemessener Größe wiedergegeben werden. Die Aufgabe ist es, einen rechteckigen Bereich eines x-y-Koordinatensystems, bei dem eine Achse nach rechts und die andere Achse nach oben zeigt, auf ein Bildschirmko-

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

111

ordinatensystem abzubilden, bei dem eine Achse nach rechts und die andere Achse nach unten zeigt. Wenn wir, um Verwechslungen zu vermeiden, die Bildschirmkoordinaten u und v nennen, ergibt sich folgender Zusammenhang:

u=umin +

(x−x min )⋅(umax −umin ) x max −xmin

und

v=vmin +

( y− ymax )⋅(v max −vmin ) y min− ymax

Abb. 117: Koordinatentransformation

Wir können diese Formeln ein wenig vereinfachen, wenn wir davon ausgehen, dass die obere linke Ecke des Zielkoordinatensystems (unsere Leinwand) immer die Koordinate (0,0) hat. Dann gilt:

u=

(x−xmin )⋅umax xmax −xmin

und v=

( y− ymax )⋅vmax y min− ymax

5.28.5. Linien und Linienzüge Mit der Methode .create_line() des Canvas-Objektes erzeugen wir Linien und Linienzüge. Als Argumente geben wir eine beliebige Zahl von Koordinatenpaaren an. Im einfachsten Fall rufen wir die Methode mit zwei Koordinatenpaaren auf.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

112

Heißt unser Canvas-Objekt beispielsweise C, so erzeugt C.create_line(100,150,250,300) eine Linie von Punkt (100,150) zu Punkt (250,300). Die Linie ist schwarz und einen Pixel breit. Um andere Farben und Breiten zu erhalten, verwenden wir die Attribute width und fill, denen wir eine Breite in Pixeln und eine Farbe zuordnen. Die Farbe definieren wir entweder über ihren (englischen) Farbnamen oder über einen RGB-Code. Eine rote Linie mit fünf Pixeln Dicke wird beispielsweise durch den Befehl C.create_line(100,150, 250,300, width=5, fill="red") erzeugt. Eine Liste von gültigen Farbnamen finden Sie in Kapitel 7.2 im Anhang. Anstatt die Koordinaten als einzelne Argumente zu übergeben, können wir sie auch in eine Liste oder ein Tupel schreiben. Die Anzahl der Koordinatenpaare ist beliebig, solange mindestens ein Start- und ein Endpunkt vorhanden sind. Punkte = (100,150, 250,300, 100,300, 250,150) C.create_line(Punkte,width=5,fill="red") Wenn wir die Befehle zum Erzeugen von Grafikobjekten direkt in der Python-Shell verwenden, stellen wir fest, dass jeder Aufruf von .create_line()

eine fortlaufen-

de Zahl erzeugt. Diese Zahl ist die Identifikationsnummer der Linie, oder kurz: ihre „ID“. Die Canvas verwaltet eine Liste aller durch ihre Methoden erzeugten Objekte und erlaubt es, diese Abb. 118: Linienzug mit Breite und Farbe

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

113

nachträglich einzeln oder in Gruppen unter anderem zu löschen, zu verschieben oder zu skalieren. Eine andere Feststellung bei unseren ersten Experimenten in der PythonShell wird sein, dass die eingetippten „Zeichenbefehle“ scheinbar nicht ausgeführt werden. Das liegt daran, dass die Canvas Aktionen nicht sofort darstellt, sondern erst, wenn die Methode .update() aufgerufen wird. Dadurch lässt sich bei komplexeren Grafiken ein beträchtlicher Geschwindigkeitsgewinn erzielen.

5.28.6. Pfeilspitzen Sowohl der Anfangs- als auch der Endpunkt einer Linie oder eines Linienzuges kann mit einer Pfeilspitze versehen werden. Je nachdem, ob der erste, der letzte oder beide Endpunkte als Pfeilspitze dargestellt werden sollen, weisen wir dem Attribut arrow den Text "first", "last" oder "both" zu.

Abb. 119: Pfeilspitzen am Anfang und/oder am Ende von Linien

Wahlweise können wir auch eine der drei vordefinierten Konstanten FIRST, LAST oder BOTH verwenden. C.create_line( 50,50,150,150, arrow="first") C.create_line(100,50,200,150, arrow="last") C.create_line(150,50,250,150, arrow="both")

5.28.7. Gestrichelte Linien Das Attribut dash erlaubt es uns, Linien auf vielfältige Arten zu stricheln. Ihm kann dazu eine Liste von Pixelangaben übergeben werden, die abwechselnd für gezeichnete und leere Linienabschnitte stehen. Die Liste (10,5,3,5) steht beispielsweise für eine strichpunktierte Linie, bei der immer wieder auf eine 10 Pixel lange Linie eine 5 Pixel breite Lücke folgt, danach eine 3 Pixel lange Linie (der "Punkt") und zum Abschluss wieder eine 5 Pixel breite Lücke.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

114

Abb. 120: Gestrichelte Linien

Bei einfachen gestrichelten Linien, deren Lücken zwischen den Strichen genauso lang sind wie die Teilstriche selbst, kann die Angabe der Lückengröße entfallen.

5.28.8. Splines (Kurvenlinien) Splines sind Kurvenzüge, deren Teilstücke aus Parabeln bestehen. Sie lassen sich ähnlich wie Linienzüge über eine Liste von Punkten definieren. Dabei werden jedoch nur der erste und letzte Punkt tatsächlich vom Spline berührt, alle anderen Punkte sind nur Tangentenschnittpunkte der einzelnen Parabeln, deren Anfangs- und Endpunkte jeweils in der Mitte der einzelnen Abschnitte des ursprünglichen Linienzuges liegen. Einen Linienzug können wir in ein Spline umwandeln, indem wir dem Attribut smooth den Wert 1 zuweisen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

115

Abb. 121: Spline und Linienzug

5.28.9. Geschlossene Polygone Geschlossene Linienzüge (Polygone) werden ganz ähnlich wie die offenen Linienzüge erzeugt. Der Unterschied besteht darin, dass wir die umschlossene Fläche mit einer Farbe füllen können. Diese Farbe weisen wir in der Methode

.create_polygon()

dem

Attribut fill zu. Die Linienfarbe des Polygonzuges wird über das Attribut mittels

outline width

definiert und

können wir ihm

eine Breite zuweisen. Das folgende Codebeispiel erzeugt das Dreieck in Abbildung 122.

Abb. 122: Dreieck als geschlossenes Polygon

from tkinter import Canvas C = Canvas(width=250, height=250, bg="white") C.pack()

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

116

punkte = (50,200, 200,200, 125,50) C.create_polygon(punkte, fill="light grey", outline="red", width=5) C.update() C.mainloop() Wenn wir das Attribut outline für die Randfarbe nicht angeben, wird kein Rand um das Polygon gezeichnet. Eine eventuell vorhandene Breitenangabe width wird dann ignoriert.

5.28.10.

Rechtecke und Ellipsen

Mit nur zwei Punkten können wir sowohl Rechtecke als auch Ellipsen definieren. Beim Rechteck sind zwei diagonal gegenüberliegende Punkte anzugeben, zwischen denen das (stets achsenparallele) Rechteck aufgespannt wird. Ellipsen (sie heißen hier Ovale) werden durch das sie umhüllende Rechteck festgelegt. C.create_rectangle(25,50, 225,200, outline="red", width=5)

Abb. 123: Rechteck und Ellipse

C.create_oval(25,50, 225,200, fill="light grey") Wenn die Randfarbe und -breite nicht angegeben werden, wird ein schwarzer Rand mit einem Pixel Breite um das Rechteck oder die Ellipse gezeichnet.

5.28.11.

Kreise

Eine eigene Methode zum Zeichnen von Kreisen ist im Canvas-Objekt nicht vorhanden. Wenn wir nicht für jeden neuen Kreis die Eckpunkte des

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

117

umhüllenden Quadrats angeben wollen, sondern diesen lieber ganz klassisch über Mittelpunkt und Radius konstruieren, können wir dazu diese selbstgeschriebene Funktion verwenden: def Kreis(C, x, y, r, width=None, fill=None, outline=None): return C.create_oval(x-r,y-r, x+r,y+r, width=width, fill=fill, outline=outline) C ist dabei die zuvor definierte Canvas, x und y sind die Koordinaten des Mittelpunktes und r ist der Radius des Kreises. Zusätzlich können noch die Attribute width, fill und outline an die erzeugende Methode .create_oval() durchgereicht werden.

5.28.12.

Text

Texte können mit der Canvas-Methode create_text() in beliebiger Größe, Farbe und Schriftart an jeder Stelle der Canvas ausgegeben werden. Im einfachsten Fall benötigen wir nur eine Koordinate und eine Zeichenkette. Der Text der Zeichenkette wird dann in Höhe und Breite zentriert am Einfügepunkt ausgegeben. C.create_text(100,150, text="Hallo Welt!") Soll der Einfügepunkt nicht mittig im Text liegen, sondern beispielsweise unten links, so ist der untere linke Punkt des Textes als Ankerpunkt zu definieren.

Abb. 124: Die Ankerpunkte eines Textes

Diese Ankerpunkte orientieren sich an den Himmelsrichtungen. Anstelle von „unten links“ sagen wir dann „Südwest“ beziehungsweise „sw“: C.create_text(100,150, text="Hallo Welt!", anchor="sw")

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

118

Zur typographischen Gestaltung weisen wir dem Attribut font ein Tupel zu, welches den Namen einer Schriftart, die Schriftgröße (in typographischen Punkten) und gegebenenfalls die gewünschten Auszeichnungen wie fett („bold“) oder kursiv („italic“) enthält. Die Textfarbe wird über das Attribut fill geändert. C.create_text(100,150, text="Hallo Welt!", anchor="sw", font=("Arial",24,"bold"), fill="red") Dass die Schriftgröße nicht wie alle anderen Koordinatenangaben bisher in Pixeln, sondern in typographischen Punkten (1/72 Zoll) angegebenen wird, ist der Konvention geschuldet, dass in dieser Einheit die gesamte Typographiebranche arbeitet. Wer unbedingt möchte, kann die Schriftgröße auch in Pixeln angegeben. Der Größenangabe ist dann ein Minuszeichen voranzustellen.

5.28.13.

GUI – Grafische Benutzeroberflächen

Um Programme zu schreiben, die komplett über die grafische Benutzeroberfläche (graphical user interface, GUI) eines eigenen Fensters bedienbar sind, benötigen wir verschiedene Arten von Ein- und Ausgabefeldern sowie Aktionsknöpfe (Buttons). Diese Elemente müssen wir so im Programmfenster anordnen, dass die wesentlichen Funktionen unseres Programms mühelos aufgerufen werden können. Für manche Programmiersprachen existieren hierzu regelrechte GUIDesign-Programme, die sehr komfortabel zu bedienen sind. Für Tkinter in Python 3 habe ich leider noch nichts brauchbares gefunden. Möglicherweise gibt es solche Programme nicht, weil es recht einfach ist, grafische Oberflächen über den Programmquelltext zu gestalten. In den folgenden Kapiteln lernen wir mehrere Möglichkeiten kennen, GUI-Elemente anzuordnen.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

119

5.28.14.

Anordnung der GUI-Elemente

Es gibt drei verschiedene Methoden, die Elemente einer grafischen Benutzeroberfläche in einem Bildschirmfenster anzuordnen:

.pack(),

.place() und .grid(). Mit .pack() werden neue Elemente einfach an eine der vier Seiten der benutzbaren Fläche „gepackt“. Für ganz einfache Programme mit wenigen Elementen mag das genügen, komplexere Layouts werden damit recht knifflig. Die Methode .place() erlaubt es, Elemente auf den Pixel (oder Millimeter) genau zu platzieren. Damit lassen sich sehr anspruchsvolle Layouts realisieren, allerdings ist die damit verbundene Pixelzählerei enorm aufwändig, solange man nicht spezielle Layoutsoftware verwendet. Einen gutes Verhältnis von Aufwand und Ergebnis erzielen wir mit der dritten Methode. Mittels .grid() weisen wir jedem Element eine Zeilenund Spaltenposition in einem imaginären Layoutraster zu. Mit wenigen Programmzeilen lassen sich so ansprechende Layouts realisieren.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

120

6. Datenspeicherung und Zahlensysteme 6.1.

Bits und Bytes

Wenn Sie dieses Buch als Python-Lehrbuch von vorne nach hinten durcharbeiten, sind Sie nun schon fast durch und haben immer noch nichts über die elementaren Grundbegriffe der Datenspeicherung gehört: Bit und Byte. Das liegt vor allem daran, dass wir uns bisher vor allem auf einer „höheren Ebene“ bewegt haben, auf der es ziemlich unwichtig ist, wie Daten tatsächlich gespeichert werden. Den ganzen Ärger, den uns eine fehlerhafte Zeichenkodierung bei der Verarbeitung von Textdateien einbringt, können wir aber nur dann wirklich vermeiden, wenn wir einen tiefen Blick in den Kaninchenbau unter der Oberfläche werfen.

6.1.1.

Das Bit

Das Bit ist die kleinste in der EDV verwendete Informationseinheit. Es kennt nur zwei definierte Zustände: „0“ und „1“. Diese lassen sich elektrisch recht einfach umsetzen, indem man auf einer Leitung eine Spannung anlegt oder nicht anlegt. Um ein Bit speichern zu können, müssen wir ein Medium finden, das von einem Zustand in einen anderen überführt werden kann. Wir können beispielsweise einen Knoten in eine Schnur knüpfen, ein Loch in ein Stück Karton stanzen, einen Punkt auf ein Blatt Papier malen, einen Bereich einer magnetischen Oberfläche umpolen, mit einem Laser einen Spiegel mattschießen oder ein paar Moleküle elektrisch aufladen. Wenn ein Speicher nur einmal bitweise beschrieben, aber mehrfach gelesen werden kann (Lochkarte, CD-R, Papier), nennen wir den Speichertyp WORM (write once, read multiple). Speicher, der zwar bitweise gelesen werden kann, aber mit einer systemfremden Technik hergestellt wurde, heißt ROM (read only memory). Musik-CDs werden beispielsweise hergestellt, indem ein Glasstempel in eine Kunststoffläche gedrückt wird, die anschließend verspiegelt, schutzlackiert und bunt bedruckt wird.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

121

Wenn Speicher beliebig gelesen und beschrieben werden kann, nennen wir ihn RAM (random access memory).

6.1.2.

Das Byte

Wollen wir größere Zahlen als 1 verarbeiten, müssen wir mehrere Bits kombinieren. Mit zwei Bits lassen sich schon vier verschiedene Zahlenwerte darstellen. Sind beide Bits null, stellen Sie die Zahl Null dar. Eine Eins entsteht dadurch, dass eines der beiden Bits den Wert 1 annimmt. Für die Zwei

Abb. 125: Beispiel für eine bitweise Speicherung auf Papier: der QR-Code für die Smartphonekamera

wird das andere Bit auf 1 gesetzt und die Drei wird dadurch repräsentiert, dass beide Bits den Wert 1 annehmen. Mit jedem zusätzlichen Bit lässt sich der darstellbare Zahlenbereich verdoppeln. Mit acht Bits können schon 2⁸, also 256 verschiedene Zustände unterschieden werden. Das reicht beispielsweise, um allen Groß- und Kleinbuchstaben des Alphabets, den wichtigsten Satzzeichen und einigen Sonderzeichen (§$%&) eine eindeutige Codenummer zuzuweisen und dadurch Texte als Folge von Zahlenwerten speichern zu können. In der weltweit verbreitetesten Zeichenkodierung ASCII (american standard code for information interchange) wird zum Beispiel dem großen „A“ die Codeposition 65 zugewiesen, dem kleinen „a“ die Position 97 und dem Leerzeichen „ “ die Position 32. Die Zeichenkette Hallo Bochum wird in der ASCII-Kodierung zur Zahlenfolge 72 97 108 108 111 32 66 111 99 104 117 109 Da die Kombination aus 8 Bit so wichtig für die elektronische Datenverarbeitung geworden ist, hat sie einen eigenen Namen bekommen. Wir nennen sie „Byte“.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

122

Je mehr Bits zur Verfügung stehen, desto größer sind die verarbeitbaren Zahlenwerte. Mit 16 Bits lassen sich schon Zahlen von 0 bis 65535 darstellen, mit 32 Bits sind rund vier Milliarden unterschiedliche Kombinationen möglich und mit 64 Bits können alle ganzen Zahlen von 0 bis ungefähr 1,84×10¹⁹ unterschieden werden. Der 32-Bit-Beschränkung begegnen wir derzeit (2012) recht häufig. So können verbreitete 32-Bit-Betriebssysteme nicht einmal 4 GiB1 RAM nutzen, ein mit dem Dateisystem FAT32 formatierter USB-Stick kann keine Dateien größer als 4294967295 Byte speichern und es gibt weltweit keine freien IP4-Adressbereiche mehr, um neue Geräte ans Internet anzuschließen, weil alle Kombinationen aus 4 Bytes schon vergeben sind.

6.1.3.

Das Hexadezimalsystem

Jede 8-Bit-Zahl können wir im uns vertrauten Dezimalsystem mit ein bis drei Dezimalziffern darstellen: 0 bis 255. Mit einem kleinen Trick lässt sich eine Ziffer einsparen, indem wir anstelle des Zehnersystems das Sechzehnersystem verwenden. Zu den zehn Ziffern 0 bis 9 kommen dann die sechs Buchstaben A bis F mit den dezimalen Ziffernwerten 10 bis 15. 0₁₀ = 0₁₆

4₁₀ = 4₁₆

8₁₀ = 8₁₆

12₁₀ = C₁₆

1₁₀ = 1₁₆

5₁₀ = 5₁₆

9₁₀ = 9₁₆

13₁₀ = D₁₆

2₁₀ = 2₁₆

6₁₀ = 6₁₆

10₁₀ = A₁₆

14₁₀ = E₁₆

3₁₀ = 3₁₆

7₁₀ = 7₁₆

11₁₀ = B₁₆

15₁₀ = F₁₆

Zahlen aus zwei Hexadezimalziffern decken somit alle 16×16 möglichen Werte eines Bytes ab. Bei mehrstelligen Hexadezimalzahlen steigt der Stellenwert nach links jeweils um den Faktor 16₁₀ = 10₁₆. Die Hexadezimalzahl 30C4 hat beispielsweise den dezimalen Wert 12484: 30C4₁₆ = 3·16·16·16 + 0·16·16 + 12·16 + 4·1 = 12484₁₀

1 Ein GiB (Gibibyte) sind 230 Byte, also rund 1,074 GB (Gigabyte). Im Microsoft-Windows-Explorer werden die Einheiten falsch verwendet und GiB-Zahlenwerte mit der Einheit GB dekoriert. Ebenso verwendet Windows die Einheit MB fälschlicherweise nicht für eine Million Bytes, sondern für 220 Bytes und kB nicht für 1000 Bytes, sondern für 1024 Bytes.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

123

Python stellt Hexadezimalzahlen als Zeichenkette dar und setzt ihnen den Präfix '0x' voran. Die Umwandlung einer solchen Zeichenkette in einen Zahlenwert geschieht mit den uns schon bekannten

Standardfunktionen

eval()

oder int() – bei letzterer muss als

Abb. 126: Umrechnung von Dezimal- und Hexadezimalzahlen

zweites Argument die Zahlenbasis 16 angegeben werden. Umgekehrt lassen sich ganzzahlige Werte mit der Funktion hex() ins Hexadezimalsystem überführen.

6.2.

Zeichenkodierung

In Kapitel 6.1.2 haben wir gesehen, dass sich Buchstaben und Satzzeichen in einem Byte speichern lassen. Seit dem Jahr 1963 ist die Zuordnung der Buchstaben von A bis Z, der Ziffern von 0 bis 9 sowie häufiger Satz-, Sonder- und Steuerzeichen im ASCII festgelegt, dem siebenbittigen American Standard Code for Information Interchange. Über Jahrzehnte wurde der ASCII unverändert benutzt, bis die Firma IBM 1981 eine Erweiterung auf 256 Zeichen für die internationale Korrespondenz mittels ihrer ersten Personal Computer zusammenstellen ließ und dazu in dieser IBM-PC8-Kodierung alle 8 Bits verwendete.

Abb. 127: Die 256 Zeichen im IBM-PC8-Zeichencode

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

124

In der Folge entstanden zahlreiche weitere Zeichenkodierungen, die den Kodepositionen oberhalb des ASCII immer wieder andere Bedeutungen zuwiesen – so standen sie beispielsweise für griechische oder kyrillische Buchstaben oder für eine größere Zahl von akzentuierten Buchstaben. Mit diesen ganzen Erweiterungen erwuchs das Problem, dass der in einem Byte gespeicherte Zahlenwert nun nicht mehr eindeutig einem bestimmten Buchstaben zuzuordnen war. Zudem gibt es auf der Welt Zeichensysteme wie die chinesische Schrift, die sich überhaupt nicht in die nur 128 zusätzlichen Positionen quetschen lassen. Ein internationales Konsortium stellte darum eine Zeichenkodierung zusammen, die alle auf der Erde verwendeten Schriftzeichen sammeln und ordnen sollte. Diese universelle Kodierung ist der Unicode. Seit der Version 3 von Python ist Unicode die standardmäßige Zeichenkodierung für alle Zeichenketten und wir müssten uns eigentlich keine weiteren Gedanken um dieses Thema machen, wenn es nicht noch viele Windowsprogramme gäbe, die nur mit den alten 8-Bit-Kodierungen umgehen können. Trauriges Beispiel ist die DOS-Shell „Eingabeaufforderung“ unter Microsoft Windows. Auch viele Dateiformate zum Datenaustausch verwenden immer noch die alten Windows-Kodierungen und wir müssen darauf gefasst sein, hier nötigenfalls korrigierend eingreifen zu müssen. Wie das in Python umgesetzt werden kann, sehen wir bei der Beschreibung der Methoden .encode() und .decode() in Kapitel 5.26.6. Eine recht unterhaltsame Kurzeinführung in dieses Thema hat Thomas Scholz in [ToSch08] verfasst.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

125

7. Anhang 7.1.

Häufige Fehlermeldungen

Fehlermeldung

Übersetzung, Bedeutung

Ursache, Behebung

Sie haben gerade Strg-C gedrückt und KeyboardIn- Programmabbruch damit die Programmausführung abgeterrupt über die Tastatur. brochen. Vermutlich haben Sie sich bei einem Variablennamen vertippt. Achten Sie auf NameError: Namensfehler: Groß- und Kleinschreibung! name 'xyz' Diesen Namen Möglicherweise haben Sie auch zwei is not defigibt es noch nicht. Programmzeilen vertauscht. Sie können ned eine Variable nicht verwenden, bevor Sie ihr einen Wert zugewiesen haben.

SyntaxError: invalid syntax

Entweder steht in der angegebenen Zeile völliger Unfug oder die Zeile darüber Sprachlicher Fehist versehentlich nicht richtig abgeler: Das Geschrieschlossen worden. Zählen Sie dort einbene ergibt keinen mal die öffnenden und schließenden Sinn. Klammern und die öffnenden und schließenden Anführungszeichen.

Eine Zeichenkette sollte in eine Kodierung überführt werden, die nicht alle enthaltenen Zeichen abdeckt. UnicodeEnKodierungsfehler: Das geschieht regelmäßig, wenn ein PycodeError: Dieses Unicodethon-Programm in der MS-DOS-Shell … can't enZeichen gibt es („Eingabeaufforderung“) von Microsoft code chahier nicht. Windows ausgeführt werden soll. racter … Vermeiden Sie entweder ausgefallene Sonderzeichen oder Microsoft Windows! DefinitionsmenValueError: genfehler: Die Einmath dogangsgröße ist für main error die Funktion ungeeignet.

Die Wurzel aus -1 und der Arkussinus von 12 lassen sich nun mal nicht so einfach ausrechnen. Vermeiden Sie den Fehler durch eine Kontrolle der Eingangswerte oder fangen Sie ihn bei Auftreten ab.

ZeroDivisionError: division by zero

Sie haben versucht, durch null zu teilen. Überprüfen Sie die Eingangswerte oder fangen Sie den Fehler über eine try-except-Konstruktion ab.

Nulldivision: Der Nenner eines Bruches darf nicht Null sein.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

126

7.2.

Farben und Farbnamen (Auswahl) Farbe

Rot

Grün Blau

RGBCode

Farbname

240

248

255 #F0F8FF alice blue

250

235

215 #FAEBD7 antique white

127

255

212 #7FFFD4 aquamarine

240

255

255 #F0FFFF azure

245

245

220 #F5F5DC beige

255

228

196 #FFE4C4 bisque

0

0

255

235

0

0

138

43

165

42

222

184

135 #DEB887 burlywood

95

158

160 #5F9EA0 cadet blue

127

255

0 #7FFF00 chartreuse

210

105

30 #D2691E chocolate

255

127

80 #FF7F50 coral

100

149

237 #6495ED cornflower blue

255

248

220 #FFF8DC cornsilk

0

255

255 #00FFFF cyan

0

0

139 #00008B dark blue

0

139

139 #008B8B dark cyan

184

134

0

100

169

169

169 #A9A9A9 dark grey

189

183

107 #BDB76B dark khaki

139

0

85

107

255

140

153

50

139

0

233

150

122 #E9967A dark salmon

143

188

143 #8FBC8F dark sea green

0 #000000 black 205 #FFEBCD blanched almond 255 #0000FF blue 226 #8A2BE2 blue violet 42 #A52A2A brown

11 #B8860B dark goldenrod 0 #006400 dark green

139 #8B008B dark magenta 47 #556B2F dark olive green 0 #FF8C00 dark orange 204 #9932CC dark orchid 0 #8B0000 dark red

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

127

Farbe

Rot

Grün Blau

RGBCode

Farbname

72

61

139 #483D8B dark slate blue

47

79

79 #2F4F4F dark slate gray

0

206

209 #00CED1 dark turquoise

148

0

211 #9400D3 dark violet

215

7

81 #D70751 debianred

255

20

147 #FF1493 deep pink

0

191

255 #00BFFF deep sky blue

105

105

105 #696969 dim gray

30

144

255 #1E90FF dodger blue

178

34

255

250

34

139

220

220

220 #DCDCDC gainsboro

248

248

255 #F8F8FF ghost white

255

215

218

165

190

190

0

255

173

255

240

255

240 #F0FFF0 honeydew

255

105

180 #FF69B4 hot pink

205

92

255

255

240 #FFFFF0 ivory

240

230

140 #F0E68C khaki

230

230

250 #E6E6FA lavender

255

240

245 #FFF0F5 lavender blush

124

252

0 #7CFC00 lawn green

255

250

205 #FFFACD lemon chiffon

173

216

230 #ADD8E6 light blue

240

128

128 #F08080 light coral

224

255

255 #E0FFFF light cyan

238

221

130 #EEDD82 light goldenrod

250

250

210 #FAFAD2 light goldenrod yellow

34 #B22222 firebrick 240 #FFFAF0 floral white 34 #228B22 forest green

0 #FFD700 gold 32 #DAA520 goldenrod 190 #BEBEBE gray 0 #00FF00 green 47 #ADFF2F green yellow

92 #CD5C5C indian red

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

128

Farbe

Rot

Grün Blau

RGBCode

Farbname

144

238

144 #90EE90 light green

211

211

211 #D3D3D3 light grey

255

182

193 #FFB6C1 light pink

255

160

122 #FFA07A light salmon

32

178

170 #20B2AA light sea green

135

206

250 #87CEFA light sky blue

132

112

255 #8470FF light slate blue

119

136

153 #778899 light slate gray

176

196

222 #B0C4DE light steel blue

255

255

224 #FFFFE0 light yellow

50

205

50 #32CD32 lime green

250

240

255

0

176

48

102

205

0

0

186

85

211 #BA55D3 medium orchid

147

112

219 #9370DB medium purple

60

179

113 #3CB371 medium sea green

123

104

238 #7B68EE medium slate blue

0

250

154 #00FA9A medium spring green

72

209

204 #48D1CC medium turquoise

199

21

133 #C71585 medium violet red

25

25

112 #191970 midnight blue

245

255

250 #F5FFFA mint cream

255

228

225 #FFE4E1 misty rose

255

228

181 #FFE4B5 moccasin

255

222

173 #FFDEAD navajo white

0

0

253

245

107

142

255

165

255

69

230 #FAF0E6 linen 255 #FF00FF magenta 96 #B03060 maroon 170 #66CDAA medium aquamarine 205 #0000CD medium blue

128 #000080 navy 230 #FDF5E6 old lace 35 #6B8E23 olive drab 0 #FFA500 orange 0 #FF4500 orange red

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

129

Farbe

Rot

Grün Blau

RGBCode

Farbname

218

112

214 #DA70D6 orchid

238

232

170 #EEE8AA pale goldenrod

152

251

152 #98FB98 pale green

175

238

238 #AFEEEE pale turquoise

219

112

147 #DB7093 pale violet red

255

239

213 #FFEFD5 papaya whip

255

218

185 #FFDAB9 peach puff

205

133

63 #CD853F peru

255

192

203 #FFC0CB pink

221

160

221 #DDA0DD plum

176

224

230 #B0E0E6 powder blue

160

32

255

0

188

143

143 #BC8F8F rosy brown

65

105

225 #4169E1 royal blue

139

69

250

128

244

164

96 #F4A460 sandy brown

46

139

87 #2E8B57 sea green

255

245

160

82

135

206

106

90

205 #6A5ACD slate blue

112

128

144 #708090 slate gray

255

250

250 #FFFAFA snow

0

255

127 #00FF7F spring green

70

130

180 #4682B4 steel blue

210

180

140 #D2B48C tan

216

191

216 #D8BFD8 thistle

255

99

64

224

208 #40E0D0 turquoise

238

130

238 #EE82EE violet

208

32

240 #A020F0 purple 0 #FF0000 red

19 #8B4513 saddle brown 114 #FA8072 salmon

238 #FFF5EE seashell 45 #A0522D sienna 235 #87CEEB sky blue

71 #FF6347 tomato

144 #D02090 violet red

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

130

Farbe

Rot

Grün Blau

RGBCode

Farbname

245

222

179 #F5DEB3 wheat

255

255

255 #FFFFFF white

245

245

245 #F5F5F5 white smoke

255

255

154

205

0 #FFFF00 yellow 50 #9ACD32 yellow green

Bei den Farben mit zusammengesetzten Namen ist auch jeweils die Schreibweise ohne Leerzeichen zulässig, zudem ist die Groß- und Kleinschreibung hier nicht relevant. Anstelle von „pale violet red“ können wir also auch „PaleVioletRed“ schreiben. Von vielen Farben existieren zusätzliche Nuancen. So gibt es beispielsweise neben „PaleVioletRed“ auch noch „PaleVioletRed1“, „PaleVioletRed2“, „PaleVioletRed3“ und „PaleVioletRed4“. Von der Farbe Grau (deren Name je nach Vorliebe „gray“ oder „grey“ geschrieben werden darf) gibt es gleich hundertundeins verschiedene Abstufungen von „grey0“ bis „grey100“. Ich empfehle, anstelle solcher nichtssagender Namen gleich die RGB-Codes zu verwenden.

7.3.

Abbildungsverzeichnis

Abb. 1: Teil des Verzeichnisbaums unter Windows 7................................10 Abb. 2: Ordneroptionen in Windows XP....................................................12 Abb. 3: Bibliotheken im Windows-Explorer...............................................13 Abb. 4: Eigene Dateien unter Windows 7..................................................14 Abb. 5: Anlegen eines ZIP-Archives über das Kontextmenü des Windows-Explorers....................................................................................15 Abb. 6: Die Zeichentabelle von Windows 8...............................................17 Abb. 7: Die tückische alte DOS-Shell........................................................17 Abb. 8: Gedit unter Ubuntu Linux.............................................................19 Abb. 9: PSPad unter Windows XP..............................................................20 Abb. 10: Tabellenkalkulation 1979............................................................21 Abb. 11: Formel einer Tabellenkalkulation...............................................22 Abb. 12: Bereichschreibweise...................................................................24 Abb. 13: Fallunterscheidung.....................................................................24 Abb. 14: x-y-Diagramm..............................................................................25 Abb. 15: Tags sind Etiketten für Textabschnitte.......................................28 Abb. 16: HTML-Struktur...........................................................................29 Abb. 17: Der Browser stellt HTML-Seiten dar..........................................30 Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

131

Abb. 18: Bestandteile eines HTML-Elements............................................31 Abb. 19: einfaches Flussdiagramm...........................................................32 Abb. 20: Struktogramm: Sequenz.............................................................33 Abb. 21: Struktogramm: Fallunterscheidung............................................33 Abb. 22: Struktogramm: Mehrfachauswahl..............................................34 Abb. 23: Struktogramm: Schleife..............................................................34 Abb. 24: Struktogramm: Nichtabweisende Schleife.................................35 Abb. 25: Struktogramm: Endlosschleife....................................................35 Abb. 26: Struktogramm: Endlosschleife mit Aussprung...........................36 Abb. 27: Struktogrammbeispiel „Zahlenraten“.........................................37 Abb. 28: Guido van Rossum 2006 (dsearls, CC-BY-SA 2.0).......................38 Abb. 29: Das Startmenü von Windows 7...................................................39 Abb. 30: Die Python-Shell der Entwicklungsumgebung IDLE..................40 Abb. 31: Die Python-Shell als Taschenrechner..........................................40 Abb. 32: Python-Fehlermeldungen............................................................41 Abb. 33: Wir können uns Variablen zunächst als kleine beschriftete Kästchen vorstellen...................................................................................42 Abb. 34: Eine Variable behält ihren Wert, bis ihr ein neuer zugewiesen wird............................................................................................................43 Abb. 35: Eingabedialoge............................................................................44 Abb. 36: Ausgabe mit print().....................................................................45 Abb. 37: Alternative Separatoren..............................................................45 Abb. 38: Zwei print-Ausgaben in einer Zeile.............................................46 Abb. 39: Typumwandlung..........................................................................48 Abb. 40: Evaluation eines arithmetischen Ausdrucks...............................48 Abb. 41: Unser erstes Python-Programm..................................................49 Abb. 42: Der Programmlauf in der Python-Shell.......................................50 Abb. 43: Kommentare im Python-Quelltext...............................................50 Abb. 44: Ganzzahlige Division und Modulo...............................................52 Abb. 45: Verkürzte Arithmetiknotation.....................................................53 Abb. 46: Rundungsfehler bei Gleitkommaoperationen.............................56 Abb. 47: Test zweier Zahlen auf Ähnlichkeit.............................................57 Abb. 48: George Boole, 1815–1864...........................................................57 Abb. 49: Wahrheitstabelle and..................................................................58 Abb. 50: Wahrheitstabelle or.....................................................................58 Abb. 51: Wahrheitstabelle ^......................................................................59 Abb. 52: Boole’sche Variablen...................................................................60 Abb. 53: Das John-Venn-Fenster in Cambridge (CC-by-SA, Schutz)..........61 Abb. 54: Venn-Diagramme und Logische Aussagen..................................62 Abb. 55: Bedingte Ausführung..................................................................62 Abb. 56: Drei Fallunterscheidungen mit if …............................................63

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

132

Abb. 57: Drei Durchläufe des vorigen Programms...................................63 Abb. 58: Mehrfachauswahl mit if … elif … else.........................................64 Abb. 59: Vereinfachung des Programmflusses durch geschachtelte Abfragen.............................................................................................................65 Abb. 60: Fehlerbehandlung.......................................................................66 Abb. 61: Anwendungsbeispiel für try…except: fehlertolerante Zahleneingabe...........................................................................................66 Abb. 62: while-Schleife..............................................................................68 Abb. 63: Flussdiagramm einer while-Schleife...........................................68 Abb. 64: Nicht abweisende Schleife..........................................................70 Abb. 65: Die while-True-…-break-Kombination.........................................71 Abb. 66: while-Schleife mit Boole’scher Hilfsvariable..............................71 Abb. 67: for-Schleife über unterschiedliche Listenelemente....................72 Abb. 68: Der Iterator range()....................................................................72 Abb. 69: Verschachtelte Schleifen.............................................................73 Abb. 70: Verschachtelte Schleifen im Flussdiagramm..............................74 Abb. 71: Verschachtelte Schleifen im Struktogramm...............................74 Abb. 72: Beispiele für Listen.....................................................................75 Abb. 73: Indizierung von Listenelementen................................................75 Abb. 74: Tupelabschnitte am Beispiel von Monatsnamen.........................76 Abb. 75: Liste: Kopie und Alias..................................................................77 Abb. 76: Vom Iterator zur Liste.................................................................77 Abb. 77: Listenerzeugung – List Comprehension......................................77 Abb. 78: Der Asterisk * zerlegt die Liste in Einzelelemente.....................78 Abb. 79: Vektoraddition mit einer klassischen Zählschleife.....................81 Abb. 80: Skalarprodukt mit einer klassischen Zählschleife......................82 Abb. 81: Formatierte Ausgabe eines Vektors............................................82 Abb. 82: Aufruf der neuen Funktion druckeVektor().................................83 Abb. 83: Matrix in mathematischer Notation und in Python-Schreibweise ...................................................................................................................83 Abb. 84: Funktionale Erzeugung der Einheitsmatrix................................84 Abb. 85: Zeilen- und Spaltenzahl einer Matrix.........................................85 Abb. 86: Kopieren von Matrizen................................................................85 Abb. 87: Transponieren einer Matrix........................................................86 Abb. 88: Matrizenaddition mit vorbelegter Zielmatrix.............................87 Abb. 89: Beispiel für eine Matrizenmultiplikation....................................88 Abb. 90: Struktogramm zur Matrizenmultiplikation.................................88 Abb. 91: Pythonprogramm zur Matrizenmultiplikation............................89 Abb. 92: Matrix-Vektor-Multiplikation.......................................................90 Abb. 93: Struktogramm des Stiefel-Algorithmus......................................91 Abb. 94: Gleichungssysteme mit 100 Unbekannten sind kein Problem

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

133

mehr...........................................................................................................93 Abb. 95: Funktionsdefinition und Aufruf mit Rückgabewert....................94 Abb. 96: Typenunabhängigkeit..................................................................94 Abb. 97: Die Anzahl der Argumente muss stimmen..................................95 Abb. 98: Vorbelegte Argumente sind optional..........................................95 Abb. 99: Übergabe von multiplen Argumenten als Liste..........................96 Abb. 100: Das redefreudige Arithmetikmodul „labermath“......................97 Abb. 101: Anzeige der Modulverzeichnisse unter Windows XP................99 Abb. 102: Funktionsweiser Import............................................................99 Abb. 103: Modulweiser Import................................................................100 Abb. 104: Das Modul „altgrad.py“..........................................................101 Abb. 105: Einbindung des Altgrad-Moduls.............................................101 Abb. 106: Programmlauf unter Verwendung des Altgrad-Moduls..........102 Abb. 107: Die Zuweisung der Funktion „print“ zur Variablen „c“ erzeugt die Funktion „c“.......................................................................................102 Abb. 108: Mehrzeilige Ausgabe (Quelle: Wikipedia, ASCII-Art).............103 Abb. 109: Formatierte Ausgabe von Gleitkommazahlen.........................104 Abb. 110: Eine selbstgebaute printf-Funktion........................................105 Abb. 111: Das Tk-Hauptfenster...............................................................108 Abb. 112: Tk-Fenster mit festgelegter Größe und Überschrift...............108 Abb. 113: Fensterdekorationen verschiedener Betriebssystemversionen .................................................................................................................109 Abb. 114: Die Leinwand in einem passenden Bildschirmfenster ...........109 Abb. 115: Erzeugung einer Zeichenfläche in vier Zeilen........................110 Abb. 116: Das tk-Koordinatensystem......................................................111 Abb. 117: Koordinatentransformation.....................................................112 Abb. 118: Linienzug mit Breite und Farbe..............................................113 Abb. 119: Pfeilspitzen am Anfang und/oder am Ende von Linien...........114 Abb. 120: Gestrichelte Linien..................................................................115 Abb. 121: Spline und Linienzug..............................................................116 Abb. 122: Dreieck als geschlossenes Polygon.........................................116 Abb. 123: Rechteck und Ellipse...............................................................117 Abb. 124: Die Ankerpunkte eines Textes.................................................118 Abb. 125: Beispiel für eine bitweise Speicherung auf Papier: der QR-Code für die Smartphonekamera.....................................................................122 Abb. 126: Umrechnung von Dezimal- und Hexadezimalzahlen..............124 Abb. 127: Die 256 Zeichen im IBM-PC8-Zeichencode............................124

7.4.

Links und Literaturhinweise

CCbySA: Creative Commons, Creative Commons by SA 3.0, 2012, http://creativecommons.org/licenses/by-sa/3.0/de/ Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

134

Lisch08: Konrad Lischka, Das Excel-Phantomschaltjahr 1900, 2008, http://www.spiegel.de/netzwelt/web/technikaergernis-tabellenkal kulation-so-falsch-rechnet-excel-a-563637-4.html NP++: Don Ho, Notepad++, 2012, http://notepad-plus-plus.org PSPad: Jan Fiala, PSPad Download, 2012, http://www.pspad.com/de/download.php PyO: Python Software Foundation, Python Programming Language – Official Website, 2012, http://www.python.org ToSch08: Thomas Scholz, Grundlagen der Zeichenkodierung, 2008, http://toscho.de/2008/grundlagen-zeichenkodierung/

7.5.

Lizenz

Der Inhalt dieses Python-Lehrbuchs ist urheberrechtlich geschützt und steht unter einer Creative-Commons-Lizenz. Das heißt, dass ich zu Recht ziemlich sauer werden kann, wenn ich Inhalte aus diesem Buch irgendwo wiederfinde, wo sie als eigenes Werk der Kopistin oder des Kopisten ausgegeben werden. Sie dürfen den Text und die Grafiken für Ihre eigenen Werke verwenden, auch verändern und weitergeben, solange Sie sich an die Creative-Commons-Lizenzbedingungen halten. Die beiden wesentlichen Punkte dieser Bedingungen lauten: Ihr eigenes Werk muss auch wieder unter einer einer Creative-Commons-Lizenz stehen und Sie müssen stets den Urheber angeben. Weitere Informationen dazu finden Sie auf der Webseite creativecommons.org/licenses/by-sa/3.0/de/ [CCbySA] Alle Bildinhalte in diesem Lehrbuch, die keine eigenen Werke des Autors sind, stehen selbst ebenfalls unter einer Creative-Commons-Lizenz oder sind gemeinfrei (public domain). Das Python-Logo ist ein eingetragenes Warenzeichen der Python Software Foundation.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

135

7.6.

Download und Feedback

Das vorliegende „E-Book“ wird bei Bedarf aktualisiert. Die jeweils neueste Version finden Sie über den Link martinvogel.de/pdf/python-lehrbuch.php Dieses Exemplar des Python-Buches wurde am 25. Januar 2013 veröffentlicht.

Martin Vogel: Grundlagen der Ingenieurinformatik mit Python 3, WS 2013/14

136