Dörn2020 Book PythonLernenInAbgeschlossenenL
Dörn2020 Book PythonLernenInAbgeschlossenenL
Dörn2020 Book PythonLernenInAbgeschlossenenL
Python lernen
in abgeschlossenen
Lerneinheiten
Programmieren für Einsteiger
mit vielen Beispielen
Python lernen in abgeschlossenen
Lerneinheiten
Programmieren für Einsteiger mit vielen Beispielen
Sebastian Dörn
Python lernen in
abgeschlossenen
Lerneinheiten
Programmieren für Einsteiger
mit vielen Beispielen
Sebastian Dörn
Hochschulcampus Tuttlingen
Tuttlingen, Deutschland
Dieses Buch basiert auf dem Buch „Java lernen in abgeschlossenen Lerneinheiten“.
Springer Vieweg
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung, die nicht
ausdrücklich vom Urheberrechtsgesetz zugelassen ist, bedarf der vorherigen Zustimmung des Verlags.
Das gilt insbesondere für Vervielfältigungen, Bearbeitungen, Übersetzungen, Mikroverfilmungen und die
Einspeicherung und Verarbeitung in elektronischen Systemen.
Die Wiedergabe von allgemein beschreibenden Bezeichnungen, Marken, Unternehmensnamen etc. in
diesem Werk bedeutet nicht, dass diese frei durch jedermann benutzt werden dürfen. Die Berechtigung
zur Benutzung unterliegt, auch ohne gesonderten Hinweis hierzu, den Regeln des Markenrechts. Die
Rechte des jeweiligen Zeicheninhabers sind zu beachten.
Der Verlag, die Autoren und die Herausgeber gehen davon aus, dass die Angaben und Informationen in
diesem Werk zum Zeitpunkt der Veröffentlichung vollständig und korrekt sind. Weder der Verlag, noch
die Autoren oder die Herausgeber übernehmen, ausdrücklich oder implizit, Gewähr für den Inhalt des
Werkes, etwaige Fehler oder Äußerungen. Der Verlag bleibt im Hinblick auf geografische Zuordnungen
und Gebietsbezeichnungen in veröffentlichten Karten und Institutionsadressen neutral.
Springer Vieweg ist ein Imprint der eingetragenen Gesellschaft Springer Fachmedien Wiesbaden GmbH
und ist ein Teil von Springer Nature.
Die Anschrift der Gesellschaft ist: Abraham-Lincoln-Str. 46, 65189 Wiesbaden, Germany
Vorwort
Können Sie mit Ihrem Computer sprechen, damit er Ihnen bei der Arbeit hilft?
Wenn nicht, dann sprechen Sie vermutlich nicht seine Sprache. Unser Freund,
der Computer, versteht kein Deutsch, Englisch, Französisch oder Spanisch. Seine
bevorzugten Sprachen sind Java, C/C++, Python, JavaScript, PHP, SQL oder
R. Alle Geräte, Maschinen oder Apps, die wir täglich verwenden, werden durch
Hunderttausende oder Millionen von Codezeilen gesteuert.
Die Kunst des Programmierens ist in unserer digitalen Informationsgesellschaft
eine Schlüsseldisziplin. Die Kreativität besteht darin, für eine Maschine eine Art
Handlungsanweisung zu erstellen, um eine spezielle Aufgabe auszuführen. Das
Ergebnis ist die Software in Form eines Quellcodes in einer Programmiersprache.
Programmieren ist deutlich mehr als das Eintippen von einzelnen Codezeilen. Ein
zentraler Aspekt beim Programmieren ist es, korrekten und sinnvoll strukturierten
Code zu schreiben. Der Programmierer muss das Programm so schreiben, dass
einzelne Abschnitte wiederverwendbar sind. Wenn wir das nicht tun, erhalten wir
sogenannten Spaghetticode – ein verworrenes Stück Programmcode. Selbst erfahre-
ne Programmierer können dieses undurchdringliche Gewirr kaum nachvollziehen.
In der digitalen Welt wird es für viele Tätigkeitsfelder immer bedeutender, dass
Menschen in der Lage sind, mit Maschinen zu kommunizieren. Programmieren
muss heutzutage neben Lesen, Schreiben und Rechnen eine Grundfertigkeit des
Menschen darstellen. Eine qualifizierte Programmiergrundausbildung ist für viele
Mitarbeiter heute unerlässlich, um bei der Planung, Konzeption und Entwicklung
von modernen Produkten und Dienstleistungen mitzuwirken. Um dem Computer
mitzuteilen, was er für uns tun soll, müssen wir dessen spezifische Regeln erlernen.
Die heutige Arbeitswelt ist durch eine starke Zunahme von programmierbaren
Systemen geprägt, die nur durch Programmierkenntnisse effizient bedienbar sind.
Mitarbeiter müssen heute in der Lage sein, sich oft wiederholende Aufgabenstel-
lungen mit Hilfe von Computerprogrammen zu automatisieren. Viele verschwenden
jedoch Stunden mit Tippen und Klicken in Office-Anwendungen, um immer die
gleichen Routineaufgaben zu bearbeiten. In der Unternehmenspraxis gibt es dafür
unzählige Beispiele: Zusammensuchen und Aufbereiten von Daten aus verschie-
denen Quellen, Erstellen von Berichten mit Abbildungen und Tabellen oder das
Versenden von vielen E-Mails mit vorformulierten Texten.
V
VI Vorwort
Abb. 1 Das Grundprinzip der Programmierung vom Problem über den Algorithmus zum
Computerprogramm
Viele dieser Aufgaben sind extrem zeitaufwendig und so speziell, dass dafür kei-
ne fertigen Softwareprodukte existieren. Meistens ist nur wenig Programmierarbeit
erforderlich, damit der Computer die notwendigen Daten zusammensucht, sinnvolle
Auswertungen erstellt und das ganze automatisch in einen Bericht überträgt. Auf
diese Weise lassen sich aufwendige Arbeitspläne oder Qualitätsberichte vollkom-
men automatisch erzeugen. Wenn sich die Datenbestände ändern, können sie durch
einen Knopfdruck neu erstellt werden.
sogenannten Quellcode mit Hilfe eines Texteditors. Die einzelnen Anweisungen des
Codes ergeben sich aus dem zugehörigen Algorithmus. Die Informatiker sprechen
beim Erstellen eines Programmiercodes von der Implementierung. Die geschrie-
benen Programme werden anschließend durch einen Compiler automatisiert in die
Maschinensprache des jeweiligen Rechners übersetzt. Damit ist unser Algorithmus
von einer Maschine ausführbar.
Es gibt heute eine große Vielfalt von unterschiedlichen Programmiersprachen
für die unterschiedlichsten Aufgaben: Entwurf von Softwaresystemen und Apps,
Auswerten von statistischen Datensätzen, Erzeugen von Steuerungsinformationen
für Werkzeugmaschinen, Programmieren von Mikroprozessoren, Abfrage von Da-
tenbanken, Erstellen von graphischen Benutzeroberflächen oder zur Konzeption von
Internetseiten.
1. Die heutigen Arbeitsumgebungen sind durch eine starke Zunahme von pro-
grammierbaren Systemen geprägt, die nur durch Programmierkenntnisse effi-
zient bedienbar sind.
2. Für viele Wissensarbeiter gehört es heute zu einer Schlüsselqualifikation,
gewisse sich oft wiederholende Aufgabenstellungen mit Hilfe von Computer-
programmen zu automatisieren.
3. Eine qualifizierte Programmiergrundausbildung ist für viele Mitarbeiter heute
unerlässlich, um bei der Planung, Konzeption und Entwicklung von modernen
Produkten und Dienstleistungen mitzuwirken.
4. Die Software gewinnt gegenüber der Hardware, sodass die Wertschöpfung
in Unternehmen nur durch die Kombination von Hardware mit zusätzlichen
digitalen Serviceleistungen auf Basis von Daten und Algorithmen zu sichern
ist.
5. In der digitalen Welt wird es für viele Tätigkeitsfelder immer bedeutender sein,
dass Menschen in der Lage sind, mit Maschinen zu kommunizieren.
6. Die Maschinensprachen werden in Zukunft wichtiger als die gesprochenen
Sprachen, da sich die Kommunikation zwischen Menschen deutlich einfacher
automatisieren lässt, als die Kommunikation zwischen Mensch und Maschine.
7. Die Analyse von Daten mit Computerprogrammen ist eine Tätigkeit, die für
Ingenieure, Naturwissenschaftler, Mediziner, Psychologen und Soziologen von
herausragender Bedeutung ist.
8. Im Zeitalter der Digitalisierung ist digitales Grundwissen für viele Berufs-
zweige von Relevanz, um neuartige Konzepte und Technologien kompetent zu
vermitteln (Lehrer), zu berichten (Journalisten), zu beurteilen (Politiker) oder
zu entscheiden (Manager).
9. Programmierkenntnisse und Algorithmen sind zentrales Grundlagenwissen für
das maschinelle Lernen, das heute im Zentrum der digitalen Wirtschaft steht.
10. Programmieren macht Spaß.
VIII Vorwort
1. Einführung: Kurze Beschreibung der Inhalte des Kapitels mit den zugehörigen
Lernzielen.
2. Konzept: Vorstellung der syntaktischen Bestandteile und Programmiermethodi-
ken mit zahlreichen Beispielen.
3. Beispiele: Ausführliche Beschreibung einiger ausgewählter Beispielprogramme
zur Festigung der Lerninhalte.
4. Zusammenfassung: Zusammenfassung der vorgestellten Konzepte zum schnel-
len Überblick.
Dieses einheitliche Schema soll Ihnen als Leser helfen, die ersten Schritte in die
Welt des Programmierens zu setzen. Großen Wert lege ich in diesem Buch auf Pro-
grammierbeispiele, damit Sie die einzelnen Konzepte begreifen und nachvollziehen
können1
1 Dieses Buch basiert auf dem gleichnamigen Java-Buch und beinhaltete dadurch Überschneidun-
gen in Inhalt.
X Vorwort
Zum Schluss sollten Sie eins beim Thema Programmieren nicht vergessen:
Danksagung
Für wertvolle Hinweise und Verbesserungsvorschläge gilt mein Dank Martina
Warmer und Werner Nörenberg.
Anhang A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
XI
Wie beginne ich mit dem
Python-Programmieren? 1
Erste Schritte in Python
Wir starten ohne große Vorrede mit der Installation der Entwicklungsumgebung
Anaconda für die Programmiersprache Python. Eine Entwicklungsumgebung ist
ein Anwendungsprogramm, das Sie als Programmierer beim Schreiben von Soft-
ware unterstützt. Anschließend verwenden wir Anaconda zum Erstellen der ersten
Python-Programme.
Unsere Lernziele
Das Konzept
In Abb. 1.1 ist die Arbeitsweise der Programmierung mit Python dargestellt:
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 1
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_1
2 1 Wie beginne ich mit dem Python-Programmieren? Erste Schritte in Python
Erstellen
Programm
*.py
Übersetzen Interpretieren
Programm
in Bytecode Eingaben
Compiler Virtuelle
*pyc
Betriebssystem- Maschine
unabhängig
Python-
Interpreter
Einbinden
Standard- Betriebssystem-
abhängig
Bibliothek
Python API Ausgaben
Für ein angenehmes Programmieren mit Python empfehle ich Ihnen die soge-
nannte IPython Variante. IPython ist eine erweiterte Python-Shell, die neben der
Das Konzept 3
Nach der Installation von Anaconda stehen Ihnen eine ganze Reihe von Umge-
bungen für das Programmieren mit Python bereit. Mit dem Starten des Anaconda
Navigator über Programme → Anaconda Navigator erhalten Sie einen guten
4 1 Wie beginne ich mit dem Python-Programmieren? Erste Schritte in Python
Abb. 1.3 Anaconda Navigator mit der Umgebung Spyder und dem Jupyter-Notebook
Überblick über die installierten Umgebungen (siehe Abb. 1.3). Die Software Spyder
(Scientific Python Development Environment) ist eine Entwicklungsumgebung für
das Programmieren in Python mit einer ganzen Reihe von nützlichen Funktionalitä-
ten. Die Benutzeroberfläche von Spyder ist grob in die folgenden vier Bestandteile
gegliedert (siehe Abb. 1.4):
In der Konsole, der sogenannten interaktive Shell, ist Python wie ein Taschenrechner
benutzbar. Hierzu geben Sie die gewünschten Anweisungen ein und führen diese mit
der Enter-Taste aus:1
1 Wir verwenden als Kennzeichung für die direkte Eingabe von Befehlen auf der Konsole die
ursprüngliche Python-Eingabeaufforderung >>>. In Anaconda entspricht dies der Eingabeauffor-
derung In[1],In[2],In[3]...
Das Konzept 5
Abb. 1.4 Die Umgebung Spyder für das angenehme Bearbeiten von Python-Code
>>> 2+3
5
>>> 34+3*434.5
1337.5
Eine Anweisung ist eine einzelne Vorschrift in der Syntax der Programmiersprache,
die im Programm ausgeführt wird. Die Shell ist sehr gut geeignet, um schnell
grundlegende Programmierkonstrukte von Python auszuprobieren.
An dieser Stelle starten wir mit dem Programmieren in Python. Wir schreiben
im Folgenden das einfachste Programm, das sogenannte „Hallo Welt“-Programm.
Hierzu legen Sie zunächst an einem sinnvollen Ort in Ihrem Dateisystem einen Ord-
ner (z. B. Programmieren) für unsere Programmierpraktika an. Für die Erstellung
eines Python-Programms legen Sie in der Entwicklungsumgebung mit File → New
file . . . in Spyder eine neue Quelldatei an. Speichern Sie diese Datei mit der Endung
py.
6 1 Wie beginne ich mit dem Python-Programmieren? Erste Schritte in Python
Nach Ausführen dieser Schritte geben Sie im Editor den folgenden Code ein:
In dem Programmeditor sehen Sie die unterschiedlichen Farben: grün für Kom-
mentare, lila für die Ausgabezeichenkette und schwarz für die Schlüsselwörter
und den restlichen Programmtext. Ein Schlüsselwort ist ein reserviertes Wort der
Programmiersprache mit einer bestimmten Bedeutung.
Das Ausführen des Programms erfolgt entweder durch Drücken auf Run in der
Menüleiste, durch Drücken auf den grünen Pfeil in der Symbolleiste oder durch
Drücken der F5-Taste. Alternativ kann das Skript mittels %run dateiname.py
auf der Konsole gestartet werden. Sie bekommen eine Fehlermeldung auf der
Konsole, wenn Sie die Groß- und Kleinschreibung nicht beachtet haben, ein Zeichen
vergessen oder falsch geschrieben haben.
Allgemeine Erklärung:
Der Funktion print() können Sie beliebig viele Argumente in der Klammer
übergeben:
print(arg1, arg2, arg3, ...)
Der Funktion input() übergeben Sie eine Zeichenkette, die dann als Eingabetext
auf der Konsole angezeigt wird.
Funktionen sind Unterprogramme, die eine gewisse Funktionalität kapseln und
über einen Funktionsaufruf ausführbar sind, wie beispielsweise das Bestimmen des
größten Elements einer Liste:
Das Konzept 7
ACHTUNG Mit Drücken von Ctrl und C-Taste oder durch Drücken auf
den roten Knopf auf der rechten oberen Seite der Konsole wird ein
ausführendes Programm sofort beendet. Mit dem Aufruf der Funktion
sys.exit() wird das aktuelle Programm sofort beendet.
+ e
Hinter dem Backslash darf kein Leerzeichen stehen, ansonsten erhalten
Sie einen Syntaxfehler. Das Zusammenfügen mehrerer Anweisungen in
einer Zeile ist mit dem Semikolon ; möglich:
a = 1; b = 2; c = 3
Verwenden Sie diese beiden Notationen nur dann, wenn der Code
dadurch besser lesbar und übersichtlicher wird.
Python-Module
Die meisten Funktionen sind in Python in sogenannten Modulen gepackt. Ein Modul
stellt Funktionen bereit, die einem bestimmten Zweck dienen, wie beispielsweise
das Modul math für das Rechnen mit mathematischen Funktionen. In Python
existieren zwei Arten von Modulen:
Für das Verwenden dieser Funktionen müssen Sie das zugehörige Modul einbinden,
wie z. B.
8 1 Wie beginne ich mit dem Python-Programmieren? Erste Schritte in Python
Das Importieren erfolgt entweder durch Eintippen dieses Befehls auf der Konsole
oder in Form der ersten Anweisung in einer Programmdatei. Die einzelnen Funktio-
nen sind dann durch den Modulnamen, den Punktoperator und den Funktionsnamen
aufrufbar:
>>> math.pi
3.141592653589793
Das Importieren von mehreren Modulen erfolgt durch das Verwenden von Kommas:
import modulname1, modulname2, ...
Mit dem Zusatz as können Sie für einem Modulnamen eine Abkürzung definieren,
einen sogenannten neuen Namensraum:
import modulname as abk
Eine weitere Form der import-Anweisung besteht aus dem Schlüsselwort from
gefolgt vom Modulnamen, dem Schlüsselwort import und dem importierten
Modulinhalt:
from modulname import xyz
Der Bezeichner xyz kann entweder für ein Modul, ein Teilpaket, ein Objekt,
eine Klasse oder eine Funktion stehen. Anstelle eines konkreten Modulinhalts
können Sie auch Sternchen setzen, damit wird alles aus dem angegebenen Modul
importiert. In diesem Fall muss das Präfix des Modulnamens nicht mehr vor der
Funktion stehen, da alle Elemente des Moduls unter dem globalen Namensraum
eingebunden werden. Im folgenden Beispiel importieren wir aus dem Modul math
das Objekt pi:
>>> from math import pi
>>> pi
3.141592653589793
Beachten Sie, dass dadurch der Code weniger verständlich wird, da nicht mehr
dasteht, aus welchem Modul die Funktion stammt. Die Namensgleichheit von zwei
Funktionen in unterschiedlichen Modulen ist eine Fehlerquelle.
TIPP Mit der Pfeiltaste nach oben können Sie die bisher eingegebe-
nen Befehle wieder aufrufen. Mit der Eingabe von einem Modulnamen,
dem Punktoperator und der Tab-Taste, zeigt Anaconda die Liste aller
möglicher Methoden an. In der Konsole wird Ihnen durch Eingabe von
help(funktionsname) ein Text zu dem angegebenen Funktionsna-
men angezeigt:
Das Konzept 9
Jupyter-Notebook
Das Jupyter Notebook ist Bestandteil der IPython-Installation von Anaconda (www.
jupyter.org). Dieses Programm ist ein freies, webbasiertes Notizbuch, das sowohl
Texte als auch Programme ausführen kann. Die Software ist ein Universalwerkzeug
zum Ausführen von über 40 Programmiersprachen und zur Dokumentation von
wissenschaftlichen Arbeiten innerhalb einer einheitlichen Web-Oberfläche.
Das Jupyter Notebook hat sich als Standardwerkzeug im Bereich der Daten-
analyse etabliert. Es wird vor allem als webbasierte Erweiterung von IPython für
die Ausführung von Python-Code verwendet. Das Notebook besteht aus einzelnen
Zellen, die verschiedene Arten von Inhalte darstellen können, wie Quellcodes, Texte
in HTML oder Markdown, Bilder oder mathematische Formeln (in Latex). Mit
dem Jupyter Notebook können Sie sehr effizient Daten auswerten, darstellen und
dokumentieren (siehe Abb. 1.5).
Nach dem Starten des Notebooks öffnet sich ein Webbrowser in Form eines
Dateiverzeichnisses:
1. Navigieren durch Klicken in einen beliebigen Ordner im Dateiverzeichnis.
2. Anlegen eines neuen Notebooks durch Klicken auf die Schaltfläche New in der
oberen rechten Seite.
3. Vergabe eines Dateinamen durch Klicken auf Untitled.
Für das optimale Verwenden des Jupyter-Notebooks sind die folgenden Befehle von
Bedeutung:
• Ausführen eines Befehls: Die aktuelle Zelle wird mit Shift + Enter an den
Python-Kernel des Notebooks geschickt, der diesen ausführt und eine Ausgabe
in einer neuen Zelle zurückgibt.
• Neue Zelle einfügen: Mit dem Drücken auf den Plus-Button in der Menüleiste
wird an der aktuellen Stelle eine neue Zelle eingefügt.
10 1 Wie beginne ich mit dem Python-Programmieren? Erste Schritte in Python
• Zelle als Text markieren: Durch Ändern des Auswahlmenüs von Code auf
Markdown (unterhalb der Menüleiste) wird eine Zelle als Text markiert (Tas-
tenkombination: Esc + m). Hier sind Texte, Bilder, mathematische Formeln (in
Latex) oder HTML-Code einfügbar.
• Zellen formatieren: Für eine Überschrift wird das Zeichen # vorangestellt.
Wenn eine solche Zelle ausgeführt wird, verschwindet die Textformatierung
und der formatierte Text wird ausgegeben. Weitere Basis-Formatierungen sind
*kursiv* und **fett**.
• Zelle löschen: Markieren der Zelle und Auswahl in der Menüleiste Edit →
Delete Cells.
• Kernel neu starten: In der Menüleiste Kernel existieren verschiedene Optionen
für das Neustarten des Kernels.
Eine zentrale Aufgabe beim Programmieren ist es, einen korrekten, übersichtlichen
und einfach gestalteten Programmcode abzuliefern. Dafür gibt es in der Praxis
zahlreiche Gründe:
In diesem Buch stellen wir für jedes neue Programmierkonzept wichtige Hinwei-
se zum Gestalten des Programmcodes vor (siehe Anhang „Codierungsregeln“).
Beachten Sie unbedingt diese Hinweise und Anregungen zum Erlernen eines
guten Programmierstils. Die allgemeinen Grundsätze für die äußere Form eines
Programmcodes sind die Folgenden:
Wenn Sie in einem Programm eine Anweisung falsch schreiben, ein Zeichen
vergessen oder die Groß- und Kleinschreibung nicht beachten, erhalten Sie vom
Compiler eine Fehlermeldung:
TIPP Wenn Sie ein Programm schreiben, testen Sie unmittelbar alle
Anweisungen auf ihre Korrektheit. Führen Sie dazu das Programm aus
und schauen Sie sich die Ergebnisse in Ruhe an. Damit lassen sich
eventuelle Probleme schneller lokalisieren und beseitigen. Erweitern Sie
anschließend das Programm mit weiterem Code, den sie ebenfalls wieder
testen.
Wir unterscheiden beim Programmieren die folgenden drei Kategorien von Fehlern:
Die Beispiele
Beispiel 1.1 (Einfacher Dialog). Wir schreiben ein Programm, das den Vornamen
und das Geburtsjahr einer Person von der Konsole einliest. Die Eingabe wird
anschließend durch eine formatierte Ausgabe wieder ausgegeben.
Die Zusammenfassung 13
Ausgabe:
Allgemeine Erklärung:
• Zeile 1–4: Eingabe des Vornamens und des Geburtsjahrs auf der Konsole. Eine
Zeichenkette wird mit der Funktion input() eingelesen.
• Zeile 5: Ausgabe der eingegebenen Informationen in einem Satz durch Verknüp-
fen der einzelnen Zeichenketten mit dem +-Operator.
Die Zusammenfassung
1. Eine Programmiersprache ist eine Sprache mit einer festen Syntax, die nur den
Einsatz spezieller Kombinationen ausgewählter Symbole und Schlüsselwörter
erlaubt. Die Schlüsselwörter sind die „Vokabeln“ der Sprache mit einer fest
vorgegebenen Bedeutung, die nicht für andere Zwecke (z. B. als Namen) ver-
wendbar sind. Die Syntax einer Programmiersprache umfasst Möglichkeiten zur
Definition verschiedener Datenstrukturen (Beschreiben von Daten), Kontroll-
strukturen (Steuern des Programmablaufs) und Anweisungen.
2. Eine Anweisung ist eine einzelne Vorschrift (z. B. print()) in der Syntax der
Programmiersprache.
3. Ein Kommentar ist ein Text im Quellcode, der vom Compiler ignoriert wird. In
Python existieren die folgenden Möglichkeiten für Kommentare:
Für das bessere Verständnis des Programms ist der Quellcode zu kommentieren.
14 1 Wie beginne ich mit dem Python-Programmieren? Erste Schritte in Python
Die Übungen
Aufgabe 1.1 (Das Modul math). Probieren Sie die Konsole, das Jupyter Notebook
und die Programmerstellung von Python aus, indem sie einfache Berechnungen wie
auf einen Taschenrechner lösen. Testen Sie am Modul math die verschiedenen
Varianten für das Importieren von Modulen.
In unserem „Hallo Welt“-Programm haben wir bisher nur eine einfache Aus-
und Eingabe erstellt. Eine der wichtigsten Aufgaben beim Programmieren ist das
Ausführen von Rechenvorschriften. Dazu benötigen wir Variablen für die Ein- und
Ausgabewerte. Diese Werte können dabei von ganz unterschiedlichen Typen sein:
z. B. ganze Zahlen, Dezimalzahlen oder Zeichenketten. Mit Werten sind wir in der
Lage mit mathematischen Operatoren (z. B. Grundrechenarten, Potenzieren oder
Wurzelziehen) zu rechnen.
Unsere Lernziele
Das Konzept
Eine Variable legen wir in Python durch eine Zuweisung mit Hilfe des Zuweisungs-
operators in Form des Gleichheitszeichens = an:
>>> zahl1 = 106
>>> zahl2 = 134.5
Der Variablenname ist eine Folge von Buchstaben, Ziffern und Symbolen, wobei
das erste Zeichen keine Ziffer sein darf. Beispiele für Namen sind a, zahl
oder nummer_1. Verwenden Sie stets aussagekräftige Namen, die mit einem
Kleinbuchstaben beginnen. In Python wird zwischen der Groß- und Kleinschreibung
unterschieden, d. h. a und A sind unterschiedliche Namen. Beachten Sie bei
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 15
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_2
16 2 Wie erstelle ich Anweisungen? Variablen, Ausdrücke und Operatoren
Dezimalzahlen den Punkt als Trennzeichen. Sie können eine Dezimalzahl mit dem
Symbol e als Zehnerpotenz schreiben, z. B. 1.82e3 für die Zahl 1820.0.
Die Werte der einzelnen Variablen sind im Laufe des Programms beliebig oft
abänderbar, z. B.
>>> zahl1 = 23
>>> zahl2 = 235.9
Die ursprünglichen Werte der Variablen werden damit überschrieben.
Das Ausführen von Rechenvorschriften erfolgt mit Hilfe von Ausdrücken durch
mathematische Operatoren. In einem Ausdruck steht auf der rechten Seite eine
Zuweisung des zu berechnenden Wertes und auf der linken Seite der Name der
Variablen:
>>> zahl = zahl1 + zahl2
258.9
Die Ausgabe des Wertes von der Variable zahl erfolgt mit der print()-
Anweisung:
>>> print("Der Wert von zahl ist", zahl, " und von zahl2 ist", zahl2)
Der Wert von zahl ist 258.9 und von zahl2 ist 235.9
Der Wert des Ausdrucks auf der rechten Seite wird in den Speicherplatz der
Variablen zahl kopiert. Ein Ausdruck der Form 20 = zahl1 liefert einen
Syntaxfehler, da auf der linken Seite kein Variablenname steht.
Variablen können Sie in Python mit den folgenden arithmetischen Operatoren
verknüpfen:
Operator Erklärung
a + b Addition
a - b Subtraktion
a * b Multiplikation
a / b Division
a ** b Exponent
a // b Ganzzahlige Division
a % b Rest bei ganzzahliger Division
Das Konzept 17
Die Ganzzahldivision dividiert zwei ganze Zahlen und schneidet den Nachkom-
mateil weg. Im Zusammenhang mit der Ganzzahldivision ist der Restwertoperator
(Modulo Operator) % ein nützlicher Operator. Der Restwertoperator % liefert den
Rest bei der ganzzahligen Division. Beispielsweise ist 11%3 = 2, da 2 der Rest ist
bei Division von 11 durch 3, also 3 · 3 + 2 = 11.
Desweiteren existieren in Python die folgenden bitweisen Operatoren:
Operator Erklärung
x << n bitweise Verschiebung von n Stellen nach links
x >> n bitweise Verschiebung von n Stellen nach rechts
x & y bitweises UND
x | y bitweises ODER
x ∧ y bitweises ausschließendes ODER (XOR)
Einfache Datentypen
Den Datentyp einer Instanzvariable können Sie mit der Funktion type() heraus-
finden:
>>> type(123.34)
float
Komplexe Zahlen können Sie in Python wie folgt definieren:
>>> c = 2+3j
Mit den Attributen c.real und c.imag ist der Realteil und der Imaginärteil
der komplexen Zahl c bestimmbar. Die Funktionen float(), bool() und
complex() wandeln die Eingabe in eine Gleitkommazahl, eine boolesche bzw.
eine komplexe Zahl um:
>>> float(20)
20.0
>>> bool(12)
True
>>> complex(20)
20 + 0j
Die Funktion int() rundet Gleitkommazahlen durch Abrunden in ganze Zahlen
um:
>>> int(10.234)
10
Falls ein Wert nicht umwandelbar ist, zeigt Python Ihnen eine Fehlermeldung an.
Das Runden einer Zahl mit angegebener Nachkommastelle erfolgt mit der Funktion
>>> round(10.345945, 3)
10.346
Die Funktion random.randint(a, b) aus dem Modul random erzeugt zufäl-
lige ganze Zahlen im Bereich der angegebenen Übergabeparameter, im folgenden
zwischen 1 und 10:
>>> import random
>>> random.randint(1, 10)
4
Das Konzept 19
Das Umwandeln einer eingelesenen Zeichenkette in eine ganze Zahl bzw. Gleit-
kommazahl erfolgt durch die folgenden beiden Funktionen:
>>> zahl1 = int(input())
>>> zahl2 = float(input())
Zeichenketten
>>> ’Python’ * 3
’PythonPythonPython’
Die Länge einer Zeichenkette mit der Anzahl der Zeichen bestimmt sich mit der
Funktion len():
>>> len(’Python’)
6
Die Funktion str(zahl) wandelt eine angegebene Zahl in einen String um.
Die folgenden Methoden sind für das Arbeiten mit Zeichenketten sehr nützlich:
Operator Erklärung
upper() Wandelt die Buchstaben in Großbuchstaben um
lower() Wandelt die Buchstaben in Kleinbuchstaben um
isalpha() Prüft, ob String nur aus Buchstaben besteht
isalnum() Prüft, ob String nur aus Buchstaben und Zahlen besteht
isdecimal() Prüft, ob String nur aus numerischen Zeichen besteht
isspace() Prüft, ob String nur aus Leerzeichen, Tabulatoren und Zeilenumbrüchen
besteht
istitle() Prüft, ob String nur aus Wörtern, die mit einem Großbuchstaben
beginnen und ansonsten nur Kleinbuchstaben enthalten
startswith(s) Prüft, ob String mit der Zeichenkette s beginnt
endswith(s) Prüft, ob String mit der Zeichenkette s endet
count(elm) Zählt die Anzahl der Vorkommen eines Elementes
find(sub) Sucht den angegebenen String vom Anfang der Zeichenkette
rfind(sub) Sucht den angegebenen String vom Ende der Zeichenkette
strip() Entfernt alle Whitespaces auf beiden Seiten der Zeichenkette
lstrip() Entfernt alle Whitespaces am Anfang der Zeichenkette
rstrip() Entfernt alle Whitespaces am Ende der Zeichenkette
Diese Methoden werden mit dem gegebenen String und dem Punktoperator ange-
wandt:
>>> ’Python’.upper()
PYTHON
Das Verbinden mehrerer Strings zu einer einzelnen Zeichenkette erledigt die
Methode join() mit einem gewünschten Verbindungszeichen und den einzelnen
Strings in eckigen Klammern:
>>> ’ ’.join([’Python’, ’ist’, ’toll’])
’Python ist toll’
Die Methode split(t) wandelt einen String mit einem angegebenen Trennzei-
chen t in die einzelnen Teilstrings um:
>>> ’Python ist toll’.split()
[’Python’, ’ist’, ’toll’]
Die Methode replace(alt, neu) ersetzt die Vorkommen der Zeichenkette
alt durch neu:
>>> s = "Programmieren ist nicht schön"
>>> s.replace("nicht", "richtig")
"Programmieren ist richtig schön"
Das Konzept 21
Der Zugriff auf einzelne Buchstaben einer Zeichenkette erfolgt über eine In-
dexschreibweise mit eckigen Klammern. Diese Syntax ist identisch zu den im
nachfolgenden erklärten eindimensionalen Listen. In Python wird jeder Buchstabe
einer Zeichenkette als ein Element einer Liste angesehen.
Eindimensionale Listen
>>> l = liste[1:3]
[2, 3]
Wenn Sie beim ersten Element beginnen oder beim letzten Element enden wollen,
können Sie zur Verkürzung der Schreibweise auf einen oder beide Indizes verzich-
ten:
>>> liste[:2]
[1, 2]
>>> liste[2:]
[3, 4]
Mit dem Slice liste[a:b:c] wird von liste der Ausschnitt von a bis
b mit jedem c-ten Element betrachtet. Die Anweisung del liste[i] löscht
das i-te Element aus der Liste. Analog dazu sind del liste[a:b] und
del liste[a:b:c] zum Löschen des angegebenen Ausschnitts anwendbar.
Die Summe der Elemente bestimmt sich mit der Funktion sum(liste). Mit
den beiden Operatoren min(liste) und max(liste) wird das kleinste und
größte Element aus der angegebenen Liste bestimmt. Die Funktion count zählt
das Vorkommen eines Elements in einer Liste:
>>> v = [1, 2, 3, 2, 2, 5]
>>> v.count(2)
3
Mit dem Plus-Operator (+) können Sie zwei Listen verketten und mit dem Mal-
Operator (*) wiederholen:
>>> liste + liste
[1, 2, 3, 4, 1, 2, 3, 4]
>>> liste * 3
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
Mit der Anweisung range(start, end, schrittweite) und der Funkti-
on list() wird eine Liste vom angegebenen Startwert start bis zum Endwert
end mit der Schrittweite schrittweite erzeugt:
>>> v = list(range(1,11,2))
1,3,5,7,9
Der Endwert wird in der range-Anweisung nicht erreicht. Diese Funktion existiert
auch in der Form range(end) bzw. range(start, end) mit dem Startwert
0 und der Schrittweite 1. Mit einer Mehrfachzuweisung können Sie in einer einzigen
Codezeile mehreren Variablen die Werte aus einer Liste zuweisen:
>>> a,b,c,d = liste
In diesem Fall müssen in der Liste genauso viele Elemente vorhanden sein, wie
Variablen angegeben sind.
Das Konzept 23
Mit den beiden Operatoren in und not in ist überprüfbar, ob sich ein Wert
wert in der Liste liste befindet oder nicht:
wert in liste
wert not in liste
Das Ergebnis ist in beiden Fällen ein boolescher Wert. Die Methode index(wert)
findet in der Liste liste den ersten Index zu dem angegebenen Wert wert:
>>> liste.index(3)
4
Falls der besagte Wert nicht in der Liste vorhanden ist, erhalten Sie als Ausgabe eine
Fehlermeldung.
Mit den Methoden append() und insert() wird ein Element element am
Ende bzw. an Position pos der Liste liste hinzugefügt:
liste.append(element)
liste.insert(pos, element)
Alle Elemente einer zweiten Liste v sind mit liste.extend(v) an die ange-
gebene Liste anhängbar. Die Methode remove() entfernt ein Element element
aus der Liste liste:
liste.remove(element)
Falls der besagte Wert nicht in der Liste vorhanden ist, erfolgt die Ausgabe einer
Fehlermeldung. Wenn das angegebene Element mehrfach in der Liste vorkommt,
so wird nur das erste Vorkommen entfernt. Mit der Methode liste.reverse()
können wir die Reihenfolge der Elemente in der Liste umkehren.
Eine Liste aus Zahlenwerten oder Strings lässt sich mit der Methode sort()
sortieren:
liste.sort()
Die Methode verwendet dazu eine ASCII-Sortierung, bei der Großbuchstaben vor
Kleinbuchstaben kommen.
ACHTUNG Beachten Sie beim Kopieren von Arrays das Prinzip der Refe-
renzvariablen:
>>> liste1 = [1,2,3,4,5]
>>> liste2 = liste1
>>> liste2[1] = -1
>>> liste1
[1, -1, 3, 4, 5]
>>> liste2
[1, -1, 3, 4, 5]
Die Anweisung liste2 = liste1 erzeugt nur eine Referenzkopie
von liste1. Überschreiben wir Elemente in liste2, so wirken sich
24 2 Wie erstelle ich Anweisungen? Variablen, Ausdrücke und Operatoren
TIPP Der Datentyp list ist sehr flexibel, jedoch dadurch auch res-
sourcenaufwendig. In Python existiert für unveränderliche Listen der
Datentyp tuple, der nur die Funktionalitäten für unveränderliche Listen
besitzt. Ein Tupel wird mit seinen Elementen durch Kommas getrennt in
runden Klammern definiert:
>>> t = (1, 2, 3, 4)
>>> t[1:]
(2, 3, 4)
Die Beispiele
Beispiel 2.1 (Berechnen von Dreiecken). Wir erstellen ein Programm zum Berech-
nen der Innenwinkel aus den gegebenen Längen eines Dreiecks. In jedem Dreieck
gelten zwischen den Seiten a, b und c mit ihren Gegenwinkeln α, β und γ die
Beziehungen:
a 2 = b2 + c2 − 2bc cos(α)
b2 = a 2 + c2 − 2ac cos(β)
c2 = a 2 + b2 − 2ab cos(γ ).
Durch Umstellen nach den Winkeln mit Anwenden der Umkehrfunktion erhalten
wir die Formeln:
2
a − b2 − c2
α = arccos
−2bc
2
b − a 2 − c2
β = arccos
−2ac
2
c − a 2 − b2
γ = arccos .
−2ab
Durch Multiplikation der Winkel mit dem Wert 180/π ergibt sich der Winkel
in Grad. Das folgende Programm berechnet die Innenwinkel in Grad aus den
gegebenen drei Seitenlängen.
26 2 Wie erstelle ich Anweisungen? Variablen, Ausdrücke und Operatoren
Ausgabe:
Allgemeine Erklärung:
• Zeile 4–6: Definition der Eingabewerte der Seiten mit einem aussagekräftigen
Kommentar.
• Zeile 9–11: Berechnen der drei Innenwinkel mit Hilfe der obigen Berechnungs-
vorschrift mit der Umkehrfunktion math.acos() und der Konstanten pi aus
dem Modul math.
• Zeile 14–16: Ausgabe der Innenwinkel durch Runden auf 4-Nachkommastellen
mit dem Ausgabebefehl print().
Ausgabe:
Allgemeine Erklärung:
Die Zusammenfassung
1. Eine Variable ist eine Art von Behälter für eine Größe, die bei Rechenprozessen
im Computerprogramm auftritt. Für alle nichtkonstanten Werte sind in einem
Programm stets Variablen zu definieren. Über den Variablennamen wird auf die
entsprechende Speicherstelle zugegriffen.
2. Ein Bezeichner ist ein Name für definierte Elemente wie Variablen, Klassen,
Methoden, usw. Der Name besteht aus einer Folge von Buchstaben, Ziffern
und Symbolen, wobei das erste Zeichen keine Ziffer sein darf (Groß- und
Kleinschreibung wird unterschieden).
3. Ein Literal ist ein fester Wert für einfache Datentypen, der direkt im Quelltext
steht, wie z. B. 23.4, 3.2e3 oder True.
4. Die Definition einer Variablen ist eine Anweisung zum Reservieren von Speicher
(Deklaration) und zum Zuweisen eines Wertes (Initialisierung):
name = wert
28 2 Wie erstelle ich Anweisungen? Variablen, Ausdrücke und Operatoren
5. Ein Ausdruck setzt sich aus Werten und Operatoren zusammen. Ein einzelner
Wert ohne Operator ist ebenfalls ein Ausdruck. Alle Ausdrücke sind stets mit
einem Semikolon abzuschließen.
6. Unter einer Liste, Array, Feld, Tupel versteht man die Zusammenfassung von
mehreren Variablen des gleichen Typs unter einem gemeinsamen Namen. Listen
treten in den meisten Fällen als ein oder zweidimensionale Felder in Form von
Tabellen oder Matrizen auf.
1. Für das Einsparen von Schreibarbeit existieren in Python die folgenden verkürz-
ten Zuweisungsoperatoren:
Die Übungen
Aufgabe 2.1 (Bestimmen von Zinsen). Schreiben Sie ein Programm Zinsen,
das einen aktuellen Anfangskapitalwert K0 [Euro] mit einem Zinssatz p [%] nach
n Jahren verzinst:
p n
Kn = K0 · 1 + .
100
Hinweis: Verwenden Sie die Methode Math.pow(a,b) aus der Klasse Math
zum Berechnen von a hoch b.
Testbeispiele:
K0 = 1000.00, n = 5, p = 2.0 folgt K5 = 1104.08
K0 = 1000.00, n = 5, p = −2.0 folgt K5 = 903.92
Hinweis: Verwenden Sie die Methode math.sqrt(a) aus dem Modul math,
um die Wurzel von a zu berechnen. Eine Seitenlänge l zwischen zwei Punkten
P1 = (x1 , y1 ) und P2 = (x2 , y2 ) bestimmt sich aus
l= (x2 − x1 )2 + (y2 − y1 )2 .
Zur besseren Übersicht berechnen Sie zunächst die Längen der Dreiecksseiten
a, b, c und anschließend die Variable s. Speichern Sie die gegebenen Punkte in dem
Datentyp list oder tuple.
Testbeispiele:
P1 = (0, 0), P2 = (2, 3), P3 = (6, 3) folgt A = 6 FE
P1 = (0, 0), P2 = (−2, 1), P3 = (2, 1) folgt A = 2 FE
Aufgabe 2.4 (Lösen einer quadratischen Gleichung). Schreiben Sie ein Pro-
gramm QuadGleichung, das die Nullstellen der quadratischen Gleichung ax 2 +
bx + c = 0 berechnet. Die Nullstellen bestimmen sich dabei über die sogenannte
Mitternachtsformel:
√
−b ± b2 − 4ac
x1,2 = .
2a
Lesen Sie die drei Zahlen a, b und c ein und geben Sie die Lösung auf vier
Nachkommastellen genau an. Speichern Sie die berechneten Lösungen als Liste ab.
Hinweis: Erstellen Sie das Programm zunächst mit einer festen Eingabe durch
die Wahl eines geeigneten Testbeispiels. Erweitern Sie das Programm erst nach er-
folgreicher Fertigstellung mit einer Eingaberoutine, um Zeit beim Testen zu sparen.
Verwenden Sie geeignete Testbeispiele für die Überprüfung des Programmcodes.
Wie erstelle ich Verzweigungen? Bedingte
Auswahlanweisungen 3
Unsere bisherigen Programme bestanden nur aus einzelnen Anweisungen, die der
Reihe nach von oben nach unten abgearbeitet wurden. Damit können wir direkte
Sequenzen der Form „Führe A gefolgt von B aus“ ausdrücken oder Programme mit
Formeln schreiben. Die Aufgabe dieses Kapitels ist, den Ablauf eines Programms
mit Verzweigungen der Form „Wenn Q, dann führe A aus, andernfalls B“ zu steuern.
Unsere Lernziele
Das Konzept
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 31
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_3
32 3 Wie erstelle ich Verzweigungen? Bedingte Auswahlanweisungen
Beim Überprüfen von Ausdrücken erhalten wir das Ergebnis True oder False,
welches wir in Variablen vom Typ bool speichern können:
>>> b1 = (4 + 6 == 10)
True
>>> b2 = (5 < 5)
False
>>> b3 = (10 != 20)
True
ACHTUNG Beachten Sie, dass der Operator == zwei Werte auf Gleichheit
überprüft, während der Operator = eine Zuweisung eines Ausdrucks
auf der rechten Seite an eine Variable auf der linken Seite durchführt.
Exakte Vergleiche zweier Gleitkommazahlen sind durch die begrenzte
Genauigkeit der Darstellung problematisch. Für einen Vergleich sind
diese Zahlen vorher zu runden.
In logischen Operatoren sind die beteiligten Operanden vom Datentyp bool mit
den beiden Werten True und False. Mit den drei booleschen Operatoren and,
or und not können boolesche Werte in Kontrollstukturen verglichen werden:
Beispielsweise ergibt sich bei dem Ausdruck (3 < 5) and (10 > 7) das
Ergebnis True, da sowohl der erste als auch der zweite Teilausdruck wahr sind:
>>> (3 < 5) and (10 > 7)
True
Mit Hilfe von logischen Operatoren und den nachfolgenden Anweisungen für
Fallunterscheidung ist der Programmablauf (Flusssteuerung) steuerbar.
Einfache-Fallunterscheidung: if-Anweisung
Die einfache Fallunterscheidung verwenden wir für die bedingte Verzweigung. Die
Syntax der einfachen if-Anweisung ist
if Bedingung:
# Anweisungen 1
else:
# Anweisungen 2
Das Konzept 33
Allgemeine Erklärung:
Falls die Bedingung zutrifft, d. h. Bedingung den Wert True hat, werden
die Anweisungen 1 ausgeführt. Trifft die Bedingung nicht zu, werden die
Anweisungen 2 ausgeführt. In Abb. 3.1 ist das zugehörige Ablaufdiagramm der
if-Anweisung dargestellt. Der else-Zweig ist optional, entfällt dieser, so spricht
man von einer bedingten Anweisung.
ACHTUNG Ein Block besteht aus einer Gruppe von Anweisungen, die
in Python eingerückt sind und hintereinander ausgeführt werden. Der
Beginn und das Ende eines Blocks wird durch Einrücken auf Basis der
folgenden Regeln durchgeführt:
Die Anweisung pass kann optional zur Signalisierung des Endes eines
Blockes verwendet werden.
Beispiel 3.1.
1. Für eine Zahl n > 0 ist die Zahl a zu halbieren und die Zahl b um zwei zu
erhöhen:
if n > 0:
a = a / 2
b = b + 2
Abb. 3.1
Einfach-Fallunterscheidung
mit if-else-Anweisung
34 3 Wie erstelle ich Verzweigungen? Bedingte Auswahlanweisungen
2. Für eine Zahl n > 0 ist die Zahl s um eins zu erhöhen, andernfalls um eins zu
verringern:
if n > 0:
s = s + 1
else:
s = s - 1
3. Für eine Zahl n ist die Ausgabe „Zahl gerade“ (Teiler 2) oder „Zahl ungerade“
(kein Teiler 2) auszugeben:
if n % 2 == 0:
print("Zahl gerade")
else:
print("Zahl ungerade")
4. Für eine Zahl 0 < n < 100 ist die Ausgabe „Zahl im Intervall“ zu schreiben:
if zahl > 0
# Anweisungen
2. Fehlende Einrückung:
if zahl > 0:
# Anweisungen
if zahl > 0:
# Anweisungen 1
else
# Anweisungen 2
Setzen Sie stets Ausdrücke in Klammern, wenn Sie diese mit logischen
Operatoren verbinden.
Mehrfach-Fallunterscheidung: elif-Anweisung
Beispiel 3.2.
Die Variable y hat den Wert 0, für x < 0, den Wert x für alle x-Werte zwischen
0 und a sowie den Wert a für alle Werte x > a:
if x < 0:
y = 0
elif (x >= 0) and (x <= a):
y = x
else:
y = a
Die Beispiele 37
if Bedingung1:
if Bedingung2:
# Anweisungen 1
else:
# Anweisungen 2
else:
# Anweisungen 3
Übung 3.1. Schreiben Sie ein Programm, das prüft, ob eine eingegebene Zahl x in
dem Intervall I1 = {x | a1 ≤ x ≤ b1 } oder I2 = {x | a2 ≤ x ≤ b2 } liegt.
Die Beispiele
Beispiel 3.3 (Definition einer mathematischen Funktion). Wir schreiben ein Pro-
gramm, das in Abhängigkeit eines Wertes t einen Ausgabewert v bestimmt.
Beispielsweise ist t der Wert eines Temperatursensors, der eine Heizungsanlage
regelt. Falls t kleiner als 0◦ ist, beträgt v = 100, zwischen 0◦ und 20◦ ist v =
100 − 5t und ab 20◦ ist v = 0. Mathematisch lässt sich diese Bedingung wie folgt
darstellen:
⎧
⎨ 100, t <0
v = 100 − 5t, 0 ≤ t < 20
⎩
0, sonst.
Ausgabe:
Allgemeine Erklärung:
• Zeile 2–3: Einlesen des Wertes der Variablen t über die Konsole.
• Zeile 6–11: Berechnen des Ausgabewertes mit Hilfe der if-else-Anweisung.
Für das Überprüfen, ob der Wert in dem angegebenen Intervall ist, werden die
zwei logischen Aussagen mit dem UND-Operator verknüpft.
• Zeile 13: Ausgabe des Ergebnisses über eine formatierte Ausgabe.
Beispiel 3.4 (Bestimmen der Tage eines Monats). Wir schreiben ein Programm,
das für einen Monat die Anzahl der zugehörigen Tage bestimmt. Wir verzichten
zunächst auf die Regelung eines Schaltjahres. Die Monate Januar, März, Mai, Juli,
August, Oktober und Dezember haben 31, die Monate April, Juni, September und
November haben 30 und der Februar 28 Tage.
Ausgabe:
Allgemeine Erklärung:
• Zeile 2–3: Einlesen des Monats über die Konsole als int-Wert.
• Zeile 6–14: Bestimmen der Anzahl der Tage mit Hilfe der elif-Anweisung.
• Zeile 17: Ausgabe der Anzahl der Tage über eine formatierte Ausgabe.
Die Übungen 39
Die Zusammenfassung
Die Übungen
Aufgabe 3.1 (Münzwurf). Schreiben Sie ein Programm, das einen Münzwurf
durch die Ausgabe „Kopf“ oder „Zahl“ simuliert.
Hinweis: Verwenden Sie für das Erzeugen einer Zufallszahl die Anweisung
random.randint(a, b) (Modul random), die eine zufällige ganze Zahlen
zwischen a und b erzeugt.
Schreiben Sie ein Programm Schrauben, die den richtigen Schraubentyp ermit-
telt, wenn Durchmesser und Länge als ganze Zahlen eingegeben werden. Sollte eine
Schraube keiner der oben beschriebenen Kategorien angehören, soll die Meldung
„Unbekannter Schraubentyp“ ausgegeben werden. Testen Sie Ihr Programm für
verschiedene Eingaben.
Aufgabe 3.4 (Schaltjahr). Schreiben Sie ein Programm Kalender zum Bestim-
men der Anzahl der Tage in einem Monat. Beachten Sie hierbei die Problematik
des Schaltjahrs, bei dem der Februar 29 statt 28 Tage besitzt. Ein Schaltjahr ist
dann, wenn die Jahreszahl durch vier und nicht durch 100 teilbar ist oder wenn die
Jahreszahl durch 400 teilbar ist.
40 3 Wie erstelle ich Verzweigungen? Bedingte Auswahlanweisungen
Der runde Halbkreis auf der x-Achse symbolisiert ein offenes Intervall
(a, ∞) = {x | x > a} für alle Zahlen größer als a. Erstellen Sie ein Programm
Steuerung, die für die Eingabe von α und x den zugehörigen Ausgabewert y
berechnet. Die dazu notwendigen Parameter a, b und w sind über die Konsole
einzulesen.
Wie wiederhole ich Anweisungen?
Iterationen und Schleifen 4
Unsere Lernziele
Das Konzept
Zählschleifen
Die for-Schleife ist eine Kontrollstruktur, die eine Gruppe von Anweisungen in
einem Block mit einer definierten Anzahl von Wiederholungen ausführt: „Führe A
genau N-mal aus.“
Beispiel 4.1. Die folgende for-Schleife gibt die ersten zehn Quadratzahlen aus:
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 41
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_4
42 4 Wie wiederhole ich Anweisungen? Iterationen und Schleifen
Ausgabe:
1 4 9 16 25 36 49 64 81 100
Allgemeine Erklärung:
Die for-Anweisung führt die folgenden Schritte durch:
1. Setze im ersten Durchlauf der Schleife die Variable i auf den Wert 1 (i=1).
2. Prüfe vor jedem Durchlauf, ob i einen Wert kleiner gleich 10 hat (i<11). Falls
ja, führt die Schleife die Anweisungen im Block aus (print(i*i)), ansonsten
bricht die Schleife ab.
3. Erhöhe nach jedem Durchlauf den Wert von i um 1 (i=i+1).
Beispiel 4.2.
s = 0
for i in range(1, n+1, 1):
s = s + i*i
Das Konzept 43
s = 1
for i in range(1, n+1, 1):
s = s * i*i
s = 0
for i in range(a, b+1, h):
s = s + i
max = feld[0]
for i in range(0, len(feld), 1):
if max < feld[i]:
max = feld[i]
anz = 0
for i in range(0, len(wort)):
if (wort[i]=="A") or (wort[i]=="a"):
anz = anz + 1
6. Berechnen der Summe der ersten n Quadratzahlen, die durch drei teilbar sind
und der Summe der ersten n Kubikzahlen die durch fünf teilbar sind:
s = 0
for i in range(1, n+1):
if i%3 == 0:
s = s + math.pow(i, 2)
if i%5 == 0:
s = s + math.pow(i, 3)
TIPP Eine alternative Möglichkeit besteht durch die Angabe einer kon-
kreten Liste für die range-Anweisung:
for variable in liste:
# Anweisungen
Um über die Indizes einer Liste liste zu iterieren wird das folgende
Konstrukt verwendet:
for variable in range(len(liste)):
# Anweisungen
44 4 Wie wiederhole ich Anweisungen? Iterationen und Schleifen
Eine weitere nützliche Variante für Schleifen ist die Funktion enumerate(),
die neben dem Laufindex (1. Wert) auch den zugehörigen Wert des
iterierbarer Datentyps (2. Wert) liefert:
liste = [’eins’, ’zwei’, ’drei’, ’vier’]
for i, wert in enumerate(liste, 1):
print(i, wert)
Ausgabe:
1 eins
2 zwei
3 drei
4 vier
Das zweite optionale Argument in der Funktion enumerate() gibt den
Startwert des Laufindex an.
a = []
for i in range(0, m):
v = [i + j for j in range(0, n)]
a.append(v)
Das Konzept 45
Bedingungsschleifen
Ein Nachteil von Zählschleifen liegt in der vorherigen Definition der Anzahl der
Schleifendurchläufe. Häufig ergeben sich während eines Schleifendurchlaufs neue
Bedingungen, die mehr oder weniger weitere Durchläufe erfordern. Beispielsweise
ist bei Näherungsverfahren nach jedem neuen Iterationsschritt zu prüfen, ob die
geforderte Genauigkeit des Ergebnisses erreicht ist. Weitere Schleifendurchläufe
sind dann nicht mehr auszuführen.
Die notwendige Flexibilität für die Anzahl der Schleifendurchläufe bietet die
sogenannte Bedingungsschleife. Die Bedingung steuert die Schleife, die vor oder
nach jedem Schleifendurchlauf überprüft wird. In Abhängigkeit davon erfolgt
entweder ein erneutes Ausführen der Anweisung im angegebenen Block oder die
Schleife wird verlassen.
Bedingungsschleifen: while-Schleife
Beispiel 4.4. Die folgende while-Schleife gibt die ersten zehn Quadratzahlen aus:
i = 1
while i <= 10:
print(i*i)
i = i+1
Ausgabe:
1 4 9 16 25 36 49 64 81 100
Allgemeine Erklärung:
Die while-Anweisung führt die folgenden Schritte durch:
1. Setze im ersten Durchlauf der Schleife die Variable i auf den Wert 1 (i=1).
2. Prüfe vor jedem Durchlauf, ob i einen Wert kleiner gleich 10 hat (i<=10). Falls
ja, führe die Schleife die beiden Anweisungen im Block aus, ansonsten bricht die
Schleife ab.
3. Wiederhole den Schritt 2 so lange, bis die Bedingung nicht mehr erfüllt ist.
Beispiel 4.5.
while n > a:
n = n/2
2. Solange wie die Differenz zwischen altem und neuem Wert größer gleich a ist,
wird eine Zahl n halbiert:
Das Konzept 47
n2 = n
while(True):
n1 = n2
n2 = n1/2
if n1 - n2 < a:
break
1. Endlosschleife:
while Bedingung:
# Anweisungen
Logikfehler: Eine Endlosschleife tritt dann auf, wenn der Wert von
Bedingung niemals den Wert False annimmt. Dieser Fall tritt
auf, wenn Sie den Wert von Bedingung im Block nicht ändern
bzw. diesen in die falsche Richtung abändern. Falls Sie durch einen
Programmierfehler eine Endlosschleife erhalten, brechen Sie diese in
Anaconda durch Drücken des roten Knopfes über der Konsole ab.
2. Fehlender Doppelpunkt nach Bedingung:
while Bedingung
# Anweisungen
Sprunganweisung
Beispiel 4.6. Wir brechen die innere for-Schleife ab, wenn die Summe der
Schleifenindizes i und j größer als 5 ist:
for i in range(1,6,1):
for j in range(1,11,1):
if i+j <= 5:
print("(" + str(i) + ", " + str(i) + ")")
else:
break
Ausgabe:
(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3),
(3, 1), (3, 2), (4, 1)
Übung 4.1. Erweitern Sie das obige Programmfragment um einen dritten Parame-
ter k, sodass alle Tripel von Zahlen zwischen 0 und 10 ausgegeben werden, deren
Summe genau 10 entspricht.
Die Beispiele
Beispiel 4.7 (Ausgabe einer Wertetabelle). Wir erstellen für das Programm aus dem
letzten Kapitel zum Berechnen einer Wertetabelle für alle ganzzahligen Werte von t
zwischen u = 0 und o = 20 die folgende Funktion:
Die Beispiele 49
⎧
⎨ 100, t <0
v = 100 − 5t, 0 ≤ t < 20
⎩
0, sonst.
Ausgabe:
(0, 100)
(1, 95)
(2, 90)
...
(18, 10)
(19, 5)
(20, 0)
Allgemeine Erklärung:
• Zeile 2–5: Definition der unteren und oberen Grenzen der Wertetabelle für die
angegebene Funktion.
• Zeile 8–15: Berechnen des Ausgabewertes mit Hilfe der if-Anweisung über
eine for-Schleife zwischen den angegebenen Intervallgrenzen. In jedem Schlei-
fendurchlauf wird das zugehörige Wertepaar ausgegeben.
Beispiel 4.8 (Würfelspiel). Wir erstellen ein Programm für ein Würfelspiel von
zwei Spielern. Jeder Spieler würfelt eine Zahl zwischen 1 und 6. Der Spieler mit
dem höchsten Wert bekommt einen Punkt. Dieses Spiel wird solange gespielt, bis
ein Spieler 10 Punkte hat.
50 4 Wie wiederhole ich Anweisungen? Iterationen und Schleifen
Ausgabe:
Allgemeine Erklärung:
• Zeile 4–6: Initialisieren der notwendigen Variablen für das Würfelergebnis, den
Spielstand und die Anzahl der Spiele.
• Zeile 8–21: Bestimmen einer Zufallszahl zwischen 1 und 6 von jedem Spieler.
Der Spieler mit dem höchsten Wert bekommt einen Punkt. Die Schleife wird
solange wiederholt, bis ein Spieler 10 Punkte hat.
• Zeile 24–27: Ausgabe des Siegers und der Anzahl der Spiele.
Beispiel 4.9 (Bestimmen der Tage eines Monats). Wir erweitern Sie das im letzten
Kapitel vorgestellte Programm Kalender zum Bestimmen der Anzahl der Tage
eines Monats. In diesem Fall soll das Programm solange ausgeführt werden, bis
wir eine ganze Zahl eingeben, die kein Monat ist. Damit ersparen wir uns das
mehrmalige Starten von Programmen.
Die Zusammenfassung 51
Ausgabe:
Allgemeine Erklärung:
• Zeile 4–5: Einlesen des Monats über die Konsole als int-Wert in jedem
Schleifendurchlauf.
• Zeile 8–16: Bestimmen der Anzahl der Tage mit Hilfe der elif-Anweisung.
• Zeile 19–20: Ausgabe der Anzahl der Tage über eine formatierte Ausgabe.
• Zeile 23–24 Abbruch der Schleife, wenn die Monatszahl nicht zwischen 1 und
12 liegt.
Die Zusammenfassung
2. Falls die Anzahl der Schleifenwiederholungen vor Eintritt in die Schleife bekannt
ist, ist die for-Zählschleife zu empfehlen.
3. Die while-Schleife ist eine abweisende Bedingungsschleife, die solange ausge-
führt wird, wie die angegebene Bedingung wahr ist.
4. Eine Schleife wird durch die Anweisung break sofort beendet und durch
continue wird zum nächsten Schleifendurchgang gesprungen.
5. Jede Kontrollstruktur kann weitere (Unter-)Kontrollstrukturen enthalten, die sich
nicht überschneiden dürfen.
Die Übungen
Aufgabe 4.1 (Würfelspiel). Schreiben Sie für das angegebene Würfelspiel die
folgenden Varianten:
(a) Der Sieger des Spieles ist der Spieler, der nach 10 Durchläufen die höchste
Augenzahl hat.
(b) Der Sieger des Spieles ist der Spieler, der zuerst die Gesamtsumme von 100
Augenzahlen besitzt.
(c) Der Sieger des Spieles ist der Spieler, der zuerst dreimal hintereinander die
gleiche Zahl würfelt.
(d) Der Sieger des Spieles ist der Spieler, der zuerst eine Sechs würfelt.
Aufgabe 4.2 (Mustererzeugung). Schreiben Sie ein Programm, das mit Hilfe von
for-Schleifen das folgende Muster erzeugt:
*
**
***
****
*****
****
***
**
*
Die maximale Anzahl von Sternen in einer Zeile soll durch eine Konstante in Ihrem
Programm vorab festgelegt werden.
Aufgabe 4.3 (Menü). Schreiben Sie ein Programm Menue zum Erstellen eines
Benutzerdialogs. Implementieren Sie das folgende Auswahlmenü:
Die Übungen 53
========================================================
Bitte wählen Sie eine Option:
1 Funktion 1
2 Funktion 2
3 Funktion 3
4 Programm beenden
Das Programm soll solange ausgeführt werden, bis der Nutzer die Zahl 4 eingibt.
Bei Auswahl einer Zahl zwischen 1 und 3 soll auf dem Bildschirm nur der
angegebene Text ausgegeben werden.
Zeichenkette: Abbcc123
Zeichenkette: b
Anzahl der Zeichen: 8
Anzahl der Buchstaben: 5
Anzahl der Zeichen b: 2
Wie strukturiere ich meinen Code?
Funktionen 5
Unsere Lernziele
Das Konzept
Das Prinzip einer Funktion können Sie sich anhand einer Firma mit verschiedenen
Abteilungen vorstellen: Jede Abteilung entspricht einer Funktion, die für das
Abarbeiten einer Aufgabe zuständig ist. Der Chef der Firma ist die Hauptfunktion,
welche die einzelnen Abteilungen mit konkreten Aufgaben versorgt. Für das Erledi-
gen der Aufgaben bekommen die Funktionen gewisse Übergabeparameter geliefert.
Aus den Werten der Parameter erstellt die Funktion ein Ergebnis in Form eines
Rückgabewertes, der an die Hauptfunktion zurückgegeben wird. So wie einzelne
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 55
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_5
56 5 Wie strukturiere ich meinen Code? Funktionen
Einführendes Beispiel
Wir betrachten das folgende Beispielprogramm zum Berechnen der Summe aller
natürlichen Zahlen von n1 bis n2 :
Ausgabe:
Summe von 10 bis 20 ist 165
Allgemeine Erklärung:
• Zeile 1–4: Definition der Funktion summe1(start, end) für das Berechnen
der Summe aller ganzen Zahlen zwischen start und end
• Zeile 6: Die Variable nach der return-Anweisung beinhaltet den Rückgabe-
wert der Funktion.
• Zeile 8–9: Definition der beiden ganzzahligen Variablen n1 und n2.
• Zeile 10: Aufruf der Funktion summe1() mit den beiden Übergabeparametern
n1 und n2 , die den Wert 10 und 20 besitzen. Damit bekommen die Parameter
start und end der Funktion summe1 die Werte 10 und 20.
• Zeile 11: Ausgabe des Ergebnisses mit dem Ausgabebefehl print().
Eine Funktion besteht in Python aus dem Schlüsselwort def, einem Funktionsna-
men, der Parameterliste, einem Doppelpunkt und einem eingerückten Codeblock in
Das Konzept 57
der nächsten Zeile. Beachten Sie, dass die beiden lokalen Variablen wert und i nur
innerhalb der Funktion summe1() existieren. Außerhalb dieser Funktion können
Sie auf diese Variablen nicht zugreifen.
Die Parameter einer Funktion spezifizieren wir durch folgende zwei Begriffe:
In der Funktion summe1() sind die formalen Parameter start und end mit den
aktuellen Parametern 10 und 20 belegt. Die Summe aller Zahlen zwischen 1 und n
ist mit der Formel n(n+1)
2 ohne Schleife bestimmbar. Wir schreiben dazu eine neue
Funktion summe2():
In der Funktion summe2() sind die formalen Parameter a und b. Alle anderen
Parameter in main() bzw. summe1() existieren in summe2() nicht. Sie bekom-
men einen Syntaxfehler, wenn Sie auf diese Variablen zugreifen wollen.
Der Aufruf einer Funktion erfolgt durch Eintippen des Funktionsnamen (hier
main()) mit den notwendigen Übergabeparametern auf der Konsole oder durch
Ergänzen des Aufrufs am Ende des Programmtextes.
Ausgabe:
Summe von 10 bis 20 ist 165
Summe von 10 bis 20 ist 165
Bei der Definition einer Funktion unterscheiden wir zwei Teile: den Funktionskopf
und den Funktionsrumpf.
58 5 Wie strukturiere ich meinen Code? Funktionen
def funktionsname(parameterliste):
# Anweisungen
parameter = wert
3. Die optionale Anweisung return gibt den Wert hinter diesem Schlüsselwort
an den Aufrufer der Funktion zurück. Das Programm kehrt dann zum Funktions-
aufruf zurück und arbeitet anschließend die nächste Anweisung ab.
4. In einer Funktion dürfen mehrere return-Anweisungen existieren, solange die
Eindeutigkeit des Rückgabewertes gewährleistet ist.
5. Funktionsaufrufe können in Programmen folgendermaßen auftreten:
Das Konzept 59
TIPP Mit Hilfe von Listen können Sie eine beliebige Menge von Parame-
tern durch eine Funktion zurückgeben. Sie speichern hierzu alle diese
Werte in einer gemeinsamen Liste:
def methode(...):
# Berechnung der Variablen a, b, c
feld = [a, b, c]
return feld
• Die Funktion ist erst nach dem Compilieren des Programms von der
Konsole aufrufbar.
• Die Reihenfolge der Übergabeparameter muss mit der Parameterliste
übereinstimmen.
• Eine Funktion darf nur genau einen Wert eines beliebigen Datentyps
zurückliefern.
• Für einen unbekannten Rückgabewert ist der Wert None (Nicht-Wert)
verwendbar.
print(sys.path)
Wir geben einige Beispiele von Funktionen mit jeweils einem Beispielaufruf an.
def ausgabeString(s):
print("Der Name lautet ", str(s))
Aufruf:
ausgabeString("Anton")
Ausgabe:
Aufruf:
Ausgabe:
Flaeche: 45,32
Aufruf:
Ausgabe:
def istGerade(zahl):
if zahl % 2 == 0:
return True
else:
return False
Aufruf:
print(istGerade(13))
print(istGerade(10))
Ausgabe:
False
True
Funktionsparameter
Der Aufruf der Funktion summe() ist dann mit zwei, drei oder vier Parametern
möglich:
>>> summe(1,2)
3
>>> summe(1,2,3)
6
>>> summe(1,2,3,4)
10
Eine beliebige Anzahl von Parametern wird durch einen Parameter mit einem
Stern vor dem Namen gekennzeichnet. In diesem Fall darf nur ein einziger
*-Parameter am Ende der Parameterliste der Funktion vorkommen. Die übergebe-
nen Werte werden dabei als Tupel abgespeichert:
def summe(a, *b):
return a + sum(b)
Der Aufruf der Funktion summe() ist dann mit zwei, drei, vier, fünf, usw. vielen
Parametern möglich:
>>> summe(1,2)
3
>>> summe(1,2,3)
6
>>> summe(1,2,3,4)
10
>>> summe(1,2,3,4,5)
15
Bei der Übergabe von Feldelementen an Funktionen müssen Sie einen wesentlichen
Punkt beachten: Falls Sie Feldelemente in der Funktion verändern, wirkt sich
diese Änderung auch auf das entsprechende Feld im rufenden Programm aus. Die
Werte der aktuellen Parameter werden dabei als Verweise bzw. Referenzen auf die
aktuellen Parameter übergeben. Damit bekommt die Funktion nicht die Werte selbst
übergeben, sondern nur einen Verweis auf den zugehörigen Speicher. Modifiziert
die Funktion den referenzierten Wert durch eine neue Wertzuweisung, so wirkt sich
diese Änderung auch auf die aktuellen Parameter aus.
Dieses Prinzip der Parameterübergabe heißt call by reference. Auf diesem Weg
wird das Kopieren von Arrays vermieden, da diese Aufgabe bei riesigen Arrays viel
Zeit kostet. Bei Variablen mit primitiven Datentypen erfolgt die Übergabe mit call
by value durch das Kopieren der aktuellen Parameter. Eventuelle Änderungen der
formalen Parameter betreffen nur diese Kopien, nicht die Orginale.
Die Beispiele 63
Beispiel 5.2. Im folgenden Programm demonstrieren wir das Prinzip des call by
reference:
Der Funktion methode() wird ein Verweis des Arrays a übergeben. Damit wirken
sich alle Änderungen in der Funktion methode() auf das ursprüngliche Array
feld aus.
Ausgabe:
[1, 2, 3, 4, 5]
[-1, 2, 3, 4, 5]
[-1, 2, 3, -1, 5]
Allgemeine Erklärung:
• Zeile 1–2: Die Funktion methode() setzt den Wert des Übergabearrays a an
der Stelle id auf −1.
• Zeile 4–10: Das Verändern der Werte des Arrays feld erfolgt mit der Funktion
methode(). Nach jeder Änderung wird der Inhalt des Feldes ausgegeben.
Die Beispiele
Beispiel 5.3 (Definition eines Funktionswertes). Wir schreiben für die bereits
vorgestellte mathematische Funktion eine passende Funktion:
⎧
⎨ 100, t <0
v = 100 − 5t, 0 ≤ t < 20
⎩
0, sonst.
Ausgabe:
100
100
50
0
Allgemeine Erklärung:
• Zeile 1–8: Definition der Funktion temp() mit dem Übergabeparameter t vom
Rückgabetyp double.
• Zeile 10–13: Aufruf der Funktion temp() mit unterschiedlichen aktuellen
Parametern.
Beispiel 5.4 (Vertauschen zweier Werte). Wir schreiben eine Funktion zum Vertau-
schen zweier Werte in einem Array durch vorgegebene Positionen i und j .
Ausgabe:
[1, 5, 3, 4, 2, 6, 7]
Die Beispiele 65
Allgemeine Erklärung:
Ausgabe:
Schmidt
[19, 3, 8, 13, 9, 4, 20]
Anton
[1, 14, 20, 15, 14]
Allgemeine Erklärung:
ganzen Zahlen um. Das Ergebnis wird in einem String gespeichert und mit
return an den Aufrufer zurückgeliefert.
• Zeile 8–9: Die Funktion zeichen2Zahl() wandelt mit der Funktion ord()
ein Zeichen in die zugehörige ganze Zahl um. Dazu wird die Darstellung des
Zeichens im ASCII-Format1 um den Wert 64 verringert.
• Zeile 11–20: Die main()-Funktion ruft die Funktion zeichenkette2Zahl()
für alle Zeichenketten auf.
Die Zusammenfassung
1. Eine zentrale Gliederungsstruktur von Funktionen ist das Trennen von Eingabe,
Algorithmus und Ausgabe. Diese grundlegenden Aufgaben sind stets durch
Funktionen voneinander zu trennen.
2. Funktionen werden in Python mit dem Schlüsselwort def eingeleitet:
def funktionsname(parameterliste):
# Anweisungen
Die Übungen
Aufgabe 5.1 (Einfache Funktionen). Schreiben Sie eine Funktion für die folgen-
den Aufgaben:
Aufgabe 5.2 (Definition von Funktionen). Schreiben Sie für einige der bisher
erstellten Programme aus den Beispielen und Übungsaufgaben der vorherigen
Kapiteln eine zugehörige Funktion.
Aufgabe 5.3 (Kreisberechnung). Schreiben Sie ein Programm mit den folgenden
Funktionen:
• umfangKreis(radius)
Berechnen des Umfangs eines Kreises.
• flaecheKreis(radius)
Berechnen des Flächeninhalts eines Kreises.
• umfangKreis(radius)
Berechnen der Summe aller Umfänge einer Menge von Kreisen.
• flaecheKreis(radius)
Berechnen der Summe aller Flächeninhalte einer Menge von Kreisen.
Rufen Sie in den Funktionen für eine Menge von Kreisen die bereits implemen-
tierten Methoden für das Berechnen des Umfangs und der Fläche der einzelnen
Kreise auf. Auf diesem Weg sparen Sie sich die abermalige Implementierung der
benötigten Formeln. Kopieren Sie das erstellte Programm mit den Funktionen in
einem neuen Ordner. Testen Sie alle Funktionen an geeigneten Testbeispielen in
einem separaten Programm. Beachten Sie hierzu den Hinweis für den Suchpfad von
Python.
(a) Schreiben Sie jeweils eine Python-Funktion für jede der angegebenen mathema-
tischen Funktionen. Definieren Sie alle notwendigen Variablen der gegebenen
Funktionen als Übergabeparameter.
(b) Schreiben Sie eine Funktion wertetabelle() für das Berechnen der Wer-
tetabelle dieser mathematischen Funktionen in einem geeigneten Intervall mit
einer definierbaren Schrittweite. Die Übergabeparameter dieser Funktion sind
die Art der Funktion, das Intervall, die Schrittweite und die Funktionsparameter.
Wie erkenne ich Muster in Zeichenketten?
Reguläre Ausdrücke 6
In vielen Anwendungen besteht die Aufgabe darin eine Zeichenkette oder einen
Text nach gewissen Mustern zu durchsuchen. Beispiele sind Telefonnummern,
E-Mail-Adressen, Postleitzahlen oder spezielle Wortmuster. Ein regulärer Ausdruck
ist eine Zeichenkette auf Basis von syntaktischen Regeln, mit denen verschiedenste
Arten von Textmustern beschreibbar sind. Mit regulären Ausdrücken können wir
Muster in Texten finden und bei Bedarf durch andere Muster ersetzen. Bei-
spielsweise ist es möglich, alle Wörter in einem Text herauszusuchen, die mit
„Sch“ beginnen und auf „en“ enden. Ebenso können wir in einer Textdatei nach
allen E-Mail-Adressen oder speziellen Codefragmenten suchen. Die Such- und
Ersetzungsfunktionen in Textverarbeitungsprogrammen arbeiten auf der Grundlage
von regulären Ausdrücken. Mit Hilfe von regulären Ausdrücken können wir in der
Praxis viel Programmieraufwand einsparen.
Unsere Lernziele
Das Konzept
Reguläre Ausdrücke dienen vor allem zum Beschreiben von Mustern, wie sie
bei der Zeichenkettenverarbeitung vorkommen. In den USA und Kanada werden
beispielsweise Telefonnummern mit einer optionalen dreistelligen Vorwahl, gefolgt
von einem Bindestrich, drei Ziffern, einem Bindestrich und vier weiteren Ziffern
angegeben (z. B. 342-555-3456). Reguläre Ausdrücke stellen Textmuster dar, mit
denen diese Art von Zeichenketten darstellbar sind. Beispielsweise steht der
Bezeichner \d in einem regulären Ausdruck für eine Ziffer. Mit dem regulären
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 69
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_6
70 6 Wie erkenne ich Muster in Zeichenketten? Reguläre Ausdrücke
pattern = re.compile(r);
id = pattern.search(s)
string = id.group()
Mit Klammern innerhalb des regulären Ausdrucks sind einzelne Gruppen anleg-
bar, die mit der Funktion group() mit dem zugehörigen Index aufrufbar sind.
Die beiden Funktionen start() bzw. end() liefern den Beginn und das Ende
der zugehörigen Positionen des regulären Ausdrucks in der Zeichenkette zurück.
TIPP Für eine kürzere Schreibweise ohne doppelten Backslash setzen Sie
vor der zu durchsuchenden Zeichenkette s ein r’. Für das Ausschalten
der Unterscheidung von GroSS- und Kleinschreibweise bei regulären
Das Konzept 71
pattern = re.compile(r’’’
(\d{3})- # Vorwahl
(\d{3})- # Nummer 1
(\d{4}) # Nummer 2
’’’, re.VERBOSE)
Mit runden Klammern innerhalb des regulären Ausdrucks können Sie einzelne
Gruppen anlegen. Wenn Sie in einem Text nach Klammern suchen, müssen vor der
öffnenden und schlieSSenden Klammer zwei Backslash-Zeichen stehen.
Die folgende Übersicht zeigt weitere Möglichkeiten zum Nutzen von regulären
Ausdrücken:
72 6 Wie erkenne ich Muster in Zeichenketten? Reguläre Ausdrücke
Operator Erklärung
? Null oder ein Vorkommen der vorangehenden Zeichengruppe
* Null oder mehr Vorkommen der vorangehenden Zeichengruppe
+ Ein oder mehr Vorkommen der vorangehenden Zeichengruppe
{m} Genau m Vorkommen der vorangehenden Zeichengruppe
{m,} m oder mehr Vorkommen der vorangehenden Zeichengruppe
{,n} Null bis n Vorkommen der vorangehenden Zeichengruppe
{m,n} m bis n Vorkommen der vorangehenden Zeichengruppe
^abc Zeichenkette muss mit abc beginnen
abc$ Zeichenkette muss mit abc enden
. beliebiges Zeichen mit Ausnahme eines Zeilenumbruchs
\d beliebige Ziffer
\w beliebiges Wortzeichen – Buchstabe, Ziffer, Unterstrich
\s beliebiges WeiSSraumzeichen – Leerzeichen, Tabulatur,
Zeilenumbruch
\D beliebiges Zeichen, das keine Ziffer ist
\W beliebiges Zeichen, das kein Wortzeichen ist
\S beliebiges Zeichen, das kein WeiSSraumzeichen ist
[abc] Zeichen, das in der Klammer vorkommt
[^abc] beliebiges Zeichen, auSSer denen in der Klammer
\p{Lower}, \p{Upper} Klein-/GroSSbuchstabe
Ausgabe:
Die Funktion findall() gibt eine Liste aller Zeichenketten mit einer Überein-
stimmung zurück.
Beispiel 6.3. Wir suchen alle amerikanischen Telefonnummer aus einer angegebe-
nen Zeichenkette heraus:
Ausgabe:
Mit regulären Ausdrücken ist es möglich mit der Funktion sub() einen Text durch
einen anderen Text zu ersetzen. Die Funktion sub() bekommt als erstes Argument
eine Zeichenkette, die jegliche gefundene Übereinstimmungen ersetzen soll, und als
zweites Argument den String des regulären Ausdrucks. Der Rückgabewert dieser
Methode ist der String mit dem ersetzten Text.
Beispiel 6.4. Wir ersetzen die englische Anrede durch die deutsche Anrede:
s = „Mr. Mueller und Mr. Ott arbeiten mit Mr. Vogt.“
pattern = re.compile(r’Mr.’)
print(pattern.sub(’Herr’, s))
Ausgabe:
Herr Mueller und Herr Ott arbeiten mit Herr Vogt.
74 6 Wie erkenne ich Muster in Zeichenketten? Reguläre Ausdrücke
Die Beispiele
Beispiel 6.5 (Extrahieren von Textmustern). Wir schreiben eine Methode zum
Extrahieren von Textmustern aus einer Zeichenkette. Die Ergebnisse werden
in einer Liste mit Elementen mit dem Muster, der Anfangs- und Endposition
gespeichert.
Ausgabe:
Allgemeine Erklärung:
• Zeile 5–8: Definition einer Zeichenkette text und einer Zeichenkette für einen
regulären Ausdrucks reg.
• Zeile 11: Erstellen eines regulären Ausdrucks mit der Methode re.compile().
• Zeile 12: Speichern der Startposition, der Endposition und des gefundenen
Textmusters in einer Liste mit Hilfe einer for-Schleife und der Methode
finditer().
• Zeile 15: Ausgabe der Elemente des Arrays.
Die Zusammenfassung
1. Ein regulärer Ausdruck ist eine Zeichenkette auf Basis bestimmter syntaktischer
Regeln, mit denen verschiedenste Arten von Textmustern beschreibbar sind.
2. Textmuster sind mit den beiden Methoden search() und findall() des
Regex-Objekts zu finden.
3. Das Ersetzen von Textmustern durch andere Muster erfolgt mit der Funktion
sub() des Regex-Objekts.
Die Übungen 75
Die Übungen
Aufgabe 6.1 (Reguläre Ausdrücke definieren). Definieren Sie für die folgenden
Muster einen regulären Ausdruck:
Der angegebene reguläre Ausdruck hat alle Beispiele für die angegebenen Muster
zu beschreiben.
Aufgabe 6.4 (Korrektur von Texten). Schreiben Sie eine Methode in die Klasse
Zeichenkette zum Entfernen von mehreren Leer- und Satzzeichen sowie
Wortwiederholungen aus einer Zeichenkette.
Wie lese ich Dateien ein? Einfache
Dateiverarbeitung 7
In vielen Programmen besteht die Aufgabe darin, Daten aus externen Dateien
einzulesen, weiterzuverarbeiten und in neue Dateien zu schreiben. In diesem Kapitel
zeigen wir verschiedene Methodiken rund um das Lesen und Schreiben von Text-,
CSV- und Excel-Dateien.
Unsere Lernziele
Das Konzept
Das Grundkonzept der Ein- und Ausgabe von Daten bildet in Python der Da-
tenstrom. Darunter versteht man einen Datenfluss zwischen einem Sender und
einem Empfänger. In Abhängigkeit der Arten von Sendern/Empfängern existieren
verschiedene Arten von Datenströmen. Beim Programmieren denken wir immer aus
Sicht des Programms, sodass der Datenfluss von der Tastatur ein Eingabestrom und
der Datenfluss an den Bildschirm ein Ausgabestrom ist.
In Windows werden Pfade mit Backslashes (\) als Trennzeichen zwischen den
Ordnernamen geschrieben, unter OS X und Linux mit einem normalen Schräg-
strich (/). Mit der Funktion os.path.join() aus dem Modul os werden die
Stringwerte der einzelnen Datei- und Ordnernamen eines Pfades übergeben, und der
Dateipfad wird als String zurückgeliefert. Mit dieser Funktion können Sie einfach
Strings für Dateinamen erstellen. Einen Dateipfad können Sie als absoluten Pfad
definieren, der stets mit dem Stammordner beginnt oder als relativen Pfad angeben,
der sich relativ zum aktuellen Arbeitsverzeichnis des Programms befindet.
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 77
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_7
78 7 Wie lese ich Dateien ein? Einfache Dateiverarbeitung
Ausgabe:
doe\Documents\Programme
C:\Users\doe\Documents\Eigene Dokumente\Vorlesungen\
A3_Programme\Python\Index.txt
C:\Users\doe\Documents\Eigene Dokumente\Vorlesungen\
A3_Programme\Python\Muster.csv
Aktuelles Verzeichnis: C:\Users\doe\Documents\Eigene
Dokumente\Vorlesungen\A3_Programme\Python
Das Konzept 79
Beim Löschen von Dateien ist Vorsicht geboten, da Sie im schlimmsten Fall
versehentlich wichtige Dateien unwiederbringlich löschen. Die Verwendung des
Moduls send2trash mit der Funktion send2trash.send2trash(path)
ist sicherer, da die angegebene Datei bzw. Ordner zunächst in den Papierkorb
verschoben wird.
Mit der Funktion os.walk(path) können Sie den gesamten angegebenen
Verzeichnisbaum durchlaufen:
Ausgabe:
Aktueller Ordner: C:\Users\doe\Documents\Eigene
Dokumente\Vorlesungen\A3_Programme\Python\
Unterordner: Programme
Datei: Hallo.py
Datei: Test.py
...
80 7 Wie lese ich Dateien ein? Einfache Dateiverarbeitung
Für das Schreiben einer neuen Textdatei sind die folgenden Schritte notwendig:
1. Öffnen der Datei im Pfad-String pfad mit der Angabe des optionalen Schreib-
modus:
Die Rückgabe ist ein File-Objekt in Form eines Dateihandles. Mit dem Argument
’w’ wird die vorhandene Datei überschrieben und mit ’a’ wird der neue Text
am Ende der Datei angehängt.
2. Schreiben einer Zeile in Form einer Zeichenkette zeile:
data.write(zeile)
data.close()
Beispiel 7.1. Wir erstellen eine Textdatei mit dem Namen Datei.txt mit den
Werten aus einem zweidimensionalen Array:
Allgemeine Erklärung:
Für das Lesen einer Textdatei sind die folgenden Schritte notwendig:
1. Öffnen der Datei im Pfad-String pfad mit der Angabe des optionalen Lesemo-
dus r:
• liste = data.read(): Liefert den gesamten Inhalt der Datei als Zei-
chenkette. Mit der Funktion liste = split() können die einzelnen
Wörter in einer Liste gespeichert werden.
• liste = data.readlines(): Liefert den gesamten Inhalt der Datei
als Liste von Zeichenketten, sodass liste[zeile] die angegebene Zeile
darstellt.
82 7 Wie lese ich Dateien ein? Einfache Dateiverarbeitung
Die Funktion rstrip() entfernt Leerzeichen und Newlines vom rechten Rand
einer Zeichenkette.
3. Schließen der Datei:
data.close()
Beispiel 7.2. Wir lesen den Inhalt der obigen Textdatei mit dem Namen
Datei.txt aus:
Ausgabe:
Allgemeine Erklärung:
ACHTUNG Beim Einlesen von Dateien treten häufig folgende Fehler auf:
1. Dateiname falsch:
Laufzeitfehler FileNotFoundError: Der Name der Datei ist falsch
geschrieben, die Groß- und Kleinschreibung wurde nicht beachtet
oder die Dateiendung stimmt nicht. Überprüfen Sie die Schreibweise
des Namens und der Dateiendung.
Das Konzept 83
2. Falsches Verzeichnis:
Laufzeitfehler FileNotFoundException: Die Datei liegt nicht in
dem angegebenen Verzeichnis. Überprüfen Sie die Lage der Datei.
Nur Dateien, die in der selben Hierarchieebene liegen, sind ohne
Pfadangabe einlesbar.
import csv
data.close()
Beispiel 7.3. Wir lesen den Inhalt einer CSV-Datei mit dem Namen Datei.csv
aus, die über 150 Zahlenwerte verfügt (siehe Abb. 7.1). Die einzelnen Zahlenwerte
speichern wir dazu in einem Array ab.
84 7 Wie lese ich Dateien ein? Einfache Dateiverarbeitung
Allgemeine Erklärung:
Für das Schreiben einer CSV-Datei sind die folgenden Schritte notwendig:
import csv
Das Konzept 85
Zusätzlich kann der Parameter delimiter für ein spezielles Trennzeichen und
lineterminator für ein Zeilenendezeichen gesetzt werden.
4. Schreiben einer eindimensionalen Liste liste1 oder einer zweidimensionalen
Liste liste2:
out.writerow(liste1)
out.writerows(liste2)
data.close()
Beispiel 7.4. Wir erstellen eine CSV-Datei mit dem Namen Datei1.csv mit den
Werten aus einem zweidimensionalen Array:
Allgemeine Erklärung:
Excel-Dateien werden sehr häufig verwendet, welche in Python mit dem Modul
openpyxl verarbeitbar sind:
import openpyxl
wb = openpyxl.Workbook()
tab = wb.active
tab.title = name
tab[zelle] = wert
bzw. mit den Attributen für die Zeile und Spalte mit Indexwerten größer gleich 1:
wb.save(dateinamen)
In den Arbeitsmappen können Sie die Schrift der Zellen, das Erscheinungsbild der
Zeilen/Spalten, Diagramme und Formeln festlegen.
Beispiel 7.5. Wir erstellen eine Excel-Datei mit dem Namen Datei.xlsx mit
drei verschiedenen Tabellen mit den Namen MeineTabelle1, MeineTabelle2
und MeineTabelle3. In das erste Tabellenblatt MeineTabelle1 schreiben
wir eine Menge von Zahlen.
Das Konzept 87
Allgemeine Erklärung:
Für das Lesen einer Excel-Tabelle sind die folgenden Schritte notwendig:
import openpyxl
wb = openpyxl.load_workbook(pfad)
blaetter = wb.get_sheet_names()
88 7 Wie lese ich Dateien ein? Einfache Dateiverarbeitung
tab = wb(blatt)
tab[zelle].value
bzw. mit den Attributen für die Zeile und Spalte mit Indexwerten größer gleich 1:
Die Größe des Arbeitsblattes liefern die beiden Methoden tab.max_row und
tab.max_column.
Beispiel 7.6. Wir lesen die obige Excel-Datei mit dem Namen Datei.xlsx ein,
geben die Namen aller Arbeitsblätter aus und den Inhalt des ersten Arbeitsblattes.
Ausgabe:
Allgemeine Erklärung:
Die Beispiele
Allgemeine Erklärung:
• Zeile 4–9 Definition eines regulärer Ausdrucks für Dateinamen mit dem ameri-
kanischen Datumsformat.
• Zeile 11–18: Durchsuchen aller Dateinamen im aktuellen Arbeitsverzeichnis
nach amerikanischen Datumsangaben mit Hilfe des regulären Ausdrucks.
• Zeile 21–34: Umbenennen der Dateinamen durch Vertauschen der Tages- und
die Monatsangabe für alle Fundstellen.
90 7 Wie lese ich Dateien ein? Einfache Dateiverarbeitung
Die Zusammenfassung
Die Übungen
Hinweise: Schreiben Sie die angegebenen Inhalte in eine Textdatei. Wenn Sie
neue Dateien schreiben, verwenden Sie einen anderen Dateinamen, da ansonsten
die ursprüngliche Datei überschrieben wird.
Wie erstelle ich objektorientierte
Programme? Objektorientierte 8
Programmierung Teil I
Unsere Lernziele
Das Konzept
Wir betrachten als einführendes Beispiel die Klasse PKW, wie in Abb. 8.1 dargestellt.
Die Klasse PKW beschreibt die Eigenschaften und Verhaltensweisen aller PKWs:
Die Attribute der Klasse PKW beschreiben die Eigenschaften der Klasse, z. B.
Marke, Modell, PS oder den Zustand eines Objekts der Klasse, z. B. Tankinhalt. Die
Methoden der Klasse PKW beschreiben das Verhalten, z. B. anlassen, fahren usw.
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 93
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_8
94 8 Wie erstelle ich objektorientierte Programme? Objektorientierte . . .
Abb. 8.1 Klasse PKW mit drei Instanzen und zugehörigen Attributen
Von der Klasse PKW sind beliebig viele Instanzen wie PKW1, PKW2, usw.
definierbar, die sogenannten Objekte der Klasse. Mit dem Anlegen einer Instanz
einer Klasse, in diesem Fall durch ein neues Automodell, werden die zugehörigen
Attributwerte für die Eigenschaften gesetzt.
Eine Klasse ist ein Konstruktionsplan für Objekte mit gleichen Eigenschaften und
gleichem Verhalten. Die Klasse definiert, wie diese Objekte aufgebaut sind und
wofür sie verwendbar sind. Eine Klasse legt dafür die Eigenschaften (Attribute)
und Verhaltensweisen (Methoden) der Objekte fest. Mit Hilfe dieses Konzeptes
sind wir in der Lage, eigene Datentypen für spezifische Aufgaben zu definieren.
Diese Datentypen fassen eine Menge von Daten und darauf operierender Methoden
zusammen.
Der Aufbau einer Klasse besteht aus einem Konstruktor mit Instanzvariablen und
Methodendefinitionen, die mit dem Schlüsselwort class, einem Bezeichner und
einem abschließenden Doppelpunkt definiert sind:
Das Konzept 95
class Klassenname:
// Konstruktor
// Methoden
Mit dem Schlüsselwort class haben wir einen neuen Datentyp namens
Klassenname definiert. Damit können wir in anderen Klassen Variablen vom
Typ Klassenname einführen.
Die Instanzvariablen einer Klasse repräsentieren den Zustand eines Objektes, die in
allen Methoden verwendbar sind. Der Konstruktor ist die Initialisierungsmethode
für die Instanzvariablen, die den Namen _ _init_ _() trägt und den Instanzvaria-
blen über den Parameter self vorgegebene Anfangswerte zuweist:
class Klassenname:
def _ _init_ _(self, parameterliste):
...
// Methoden
Der Parameter self ist immer der erste Variablenname in der Parameterliste des
Konstruktors, er stellt eine Referenz auf das Objekt selbst dar. Konstruktoren haben
keine Rückgabewerte, da sie nicht direkt aufgerufen werden. Die Methoden der
Klasse legen das Verhalten von Objekten fest und arbeiten immer mit den Variablen
des aktuellen Objektes.
Als Beispiel betrachten wir hier die Klasse Adresse, mit der wir Objekte in Form
von Adressen von Personen definieren. Die Klasse hat gewisse Eigenschaften in
Form von Variablen (strasse, nummer, postleitzahl, stadt) und Verhal-
tensweisen in Form von Methoden (getAdresse(), aendereAdresse()).
96 8 Wie erstelle ich objektorientierte Programme? Objektorientierte . . .
Allgemeine Erklärung:
• Zeile 4–8: Definition des Konstruktors mit der Methode _ _init_ _() für das
Initialisieren der Instanzvariablen mit den übergebenen Parametern.
• Zeile 11–13: Definition einer Methode zur Rückgabe der vollständigen Adresse
in Form einer Zeichenkette.
Durch die Definition der Klasse haben wir einen neuen Datentyp Adresse
erstellt. Mit der folgenden Anweisung sind Objekte dieser Klasse in Form von
Instanzvariablen mit konkreten Werten belegbar:
klname = Klassenname(wert1, wert2, ...)
Mit dieser Anweisung wird automatisch bei der Objekterzeugung der Konstruktor
aufgerufen. Die Variable klname heißt Objektvariable. Diese Variable ist ein
Objekt oder eine Instanz ihres Klassentyps. Damit haben wir ein echtes Objekt und
nicht mehr nur eine Anhäufung von einzelnen Variablen. Mit Hilfe der Objektvaria-
blen klname und des Punktoperators (.) können wir auf die Instanzvariablen und
die Methoden des Objektes zugreifen.
Ausgabe:
Schätzlestrasse 10, 78534 Schwabingen
Katharinenstrasse 6, 20459 Hamburg
Allgemeine Erklärung:
• Zeile 3–4: Definition zweier Objekte der Klasse Adresse durch Übergabe
der aktuellen Parameterwerte. Die Variablen paul_muellerle und
Das Konzept 97
Die objektorientierte Programmierung hat die Aufgabe, die Programme sicherer und
robuster zu machen. Für die obige Klasse Adresse trifft diese Forderung noch
nicht zu, da beispielsweise die Instanzvariable plz Zahlen enthalten kann, die keine
fünf Stellen besitzen. Mit Hilfe von Sichtbarkeitstypen schützen wir Instanzvaria-
blen vor falschen Werten. Diese Schlüsselwörter werden in der Klassendefinition
den Klassenelementen vorangestellt:
• public: Das Element kann innerhalb der eigenen Klasse und in allen anderen
Klassen verwendet werden. Alle Variablen und Methoden sind in Python stan-
dardmäßig public.
• protected: Das Element kann in der eigenen und in Klassen, die von dieser abge-
leitet sind, verwendet werden. Mit dem voranstellen eines einzelnen Unterstrichs
wird ein Element als protected gekennzeichnet.
• private: Das Element kann nur innerhalb der eigenen Klasse verwendet werden.
Mit dem voranstellen von zwei Unterstrichen wird ein Element als private
gekennzeichnet.
Mit diesen Zugriffsmethoden stellen wir einen kontrollierten Zugriff auf die Instanz-
variablen sicher. Um die Instanzvariablen unserer Klasse Adresse vor falschen
Werten zu schützen, deklarieren wir alle Instanzvariablen von public auf private:
98 8 Wie erstelle ich objektorientierte Programme? Objektorientierte . . .
Allgemeine Erklärung:
1. Zeile 4–7: Definition und Initalisieren der Instanzvariablen der Klasse Adresse
mit dem Sichtbarkeitstyp private und den übergebenen Parametern.
2. Zeile 8–11: Prüfen im Konstruktor, ob die vorgegebene Zahl plz einer
5-stelligen Zahl entspricht. Falls das nicht der Fall ist, wird eine Fehlermeldung
ausgegeben.
Der Zugriff von außen auf ein Attribut mit dem Modifier private ist durch eine
Methode möglich, die Auskunft über den aktuellen Wert des Attributs gibt, die
sogenannte Getter-Methode. Für jede Variable der Klasse wird eine solche Methode
erstellt, die als Ergebnis den Wert der betreffenden Variablen bzw. das Attribut
zurückliefert. Es ist üblich, als Namen den Bezeichner getAttributname zu
verwenden:
def getAttributname(self):
{
return self._ _variablenname
}
Methoden zum Zuweisen von neuen Werten für einzelne Attribute heißen
Setter-Methoden. Als Bezeichner wird in vielen Fällen setAttributname
verwendet:
Für die obige Beispielklasse Adresse erstellen wir verschiedene Getter- und
Setter-Methoden:
Das Konzept 99
Allgemeine Erklärung:
ACHTUNG Der Code in einer Klasse sollte wie eine Erzählung von oben
nach unten lesbar sein. Schreiben Sie zusammengehörige Fakten stets
eng beieinander. Im oberen Teil der Quelldatei sollten die Instanzvaria-
blen und die wichtigsten Konzepte stehen. Die Detailtiefe nimmt nach
unten hin zu, wobei am Ende die Hilfsmethoden stehen. Sinnvoll ist
es, hinter jeder Methode die Methode auf der nächsttieferen Abstrakti-
onsebene zu schreiben. Die aufrufende Methode sollte möglichst über
der aufgerufenen Methode stehen. Typischerweise sollte die Größe einer
Datei nicht 500 Zeilen überschreiten.
Die Beispiele
Beispiel 8.1 (Klasse Kreis). Wir definieren eine Klasse Kreis zur Repräsentation
von geometrischen Kreisobjekten. Die Klasse wird durch die Attribute in Form
Die Beispiele 101
Beachten Sie, dass from Kreis import Kreis bedeutet, dass aus der Datei
Kreis die Klasse Kreis importiert wird. Verwenden Sie für eine bessere Übersicht
immer separate Dateien für die Klassendefinition und die Testprogramme.
Ausgabe:
Gesamtflaeche = 19,76
Mittelpunkt: [1.3, 2.5]
Anzahl der Kreisobjekte: 2
Allgemeine Erklärung:
Die Zusammenfassung
1. Alle Dinge sind Objekte. Die Objekte sind Instanzen einer Klasse. In einer Klasse
ist die Verhaltensweise der Objekte implementiert. Jedes Objekt besitzt einen
eigenen Speicherbereich für seine zugehörigen Daten. Mit dem Austausch von
Objekten kommunizieren die einzelnen Objekte miteinander.
Die Übungen 103
• Lokale Variable, die innerhalb einer Methode oder eines Blocks definiert wird,
und nur dort existiert.
• Klassenvariable, die außerhalb einer Methode definiert wird.
• Instanzvariable, die im Rahmen einer Klassendefinition definiert und zusam-
men mit dem Objekt angelegt wird.
4. Der Konstruktor ist die Initialisierungsmethode für die Instanzvariablen, die den
Namen _ _init_ _() trägt und den Instanzvariablen über den Parameter self
vorgegebene Anfangswerte zuweist. Der Parameter self ist dabei stets der erste
Variablenname im Konstruktor und stellt eine Referenz auf das Objekt selbst dar.
5. Die Methoden der Klasse legen das Verhalten von Objekten fest und arbeiten
immer mit den Variablen des aktuellen Objektes.
6. Die Abstraktion beschreibt die Vorgehensweise, unwichtige Einzelheiten auszu-
blenden und Gemeinsamkeiten zusammenzufassen. Die Abstraktion beschreibt
gleichartige Objekte mit gemeinsamen Merkmalen mit Hilfe von Klassen, ohne
eine genaue Implementierung.
7. Die Kapselung stellt den kontrollierten Zugriff auf Attribute bzw. Methoden
einer Klasse dar. Das Innenleben einer Klasse bleibt dem Nutzer weitestgehend
verborgen (Geheimnisprinzip). In einer Klasse sind die nach außen sichtbaren
Methoden eines Objektes die Schnittstelle, die zur Interaktion mit anderen
Klassen dienen.
8. Die Datenkapselung schützt die Variablen einer Klasse vor unberechtigtem
Zugriff von außen und bietet eine Reihe von Vorteilen:
Die Übungen
Aufgabe 8.1 (Klasse Kreis). Erweitern Sie die Klasse Kreis mit einer Instanz-
variable farbe und eine Methode getUmfang() zur Berechnung des Um-
fangs. Definieren Sie zwei weitere sinnvolle Konstruktoren sowie die zugehörigen
Getter- und Setter-Methoden für die Variable farbe. Erzeugen Sie anschließend
104 8 Wie erstelle ich objektorientierte Programme? Objektorientierte . . .
Aufgabe 8.2 (Klasse Rechteck). Implementieren Sie eine Klasse Rechteck zur
Repräsentation von Rechtecken. Diese Klasse soll die gleiche Funktionalität wie die
Klasse Kreis besitzen. Erzeugen Sie anschließend verschiedene Rechteckobjekte
in der separaten Testklasse und überprüfen Sie die vorhandenen Methoden.
Aufgabe 8.3 (Klasse Schrank). Implementieren Sie eine Klasse Schrank mit
den Instanzvariablen name für den Modellnamen, einem Array abmessung
für die Länge, Breite und Höhe und preis für den Preis. Erstellen Sie drei
Konstruktoren für zwei Einheitsschränke sowie für einen allgemeinen Schranktyp.
Schreiben Sie neben den notwendigen Getter- und Setter-Methoden noch die
folgenden Methoden:
• getVolumen()
Berechnen des Volumens eines Schrankes.
• getPreis()
Berechnen des Preises eines Schrankes über eine geeignete Vorschrift aus dem
Volumen.
• getInfo()
Ausgabe der vollständigen Schrankeigenschaften als Zeichenkette.
• getAnzahl()
Rückgabe der Anzahl der definierten Schränke mit Hilfe der Klassenvariablen
zaehler.
Mit einer Klasse haben wir einen selbst definierten Datentyp mit Eigenschaften
in Form von Instanzvariablen und Verhaltensweisen mittels Methoden erstellt. Die
konkrete Realisierung einer Klasse sind die Objekte. Diese Objekte können wir in
anderen Klassen wiederum als Instanzvariablen verwenden. Auf diesem Weg sind
wir in der Lage, ein neues Objekt aus anderen Objekten zusammenzusetzen.
Unsere Lernziele
Das Konzept
Viele Objekte entstehen durch das Zusammensetzen eines Objektes aus anderen
Objekten. Wir zeigen dieses Prinzip anhand der Klasse Person, deren Instanzva-
riablen das Objekt Adresse sowie die beiden Zeichenketten name für den Namen
und vorname für den Vornamen einer Person sind.
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 105
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_9
106 9 Wie erstelle ich objektorientierte Programme? Objektorientierte . . .
Allgemeine Erklärung:
Für das Testen dieser Klasse schreiben wir das folgende Programm (die Klasse
Adresse befindet sich hier in der Datei Adresse2):
Das Konzept 107
Ausgabe:
Müllerle Paul, Schätzlestraße 10, 78534 Schwabingen
Schmitt Ute, Katharinenstraße 6, 20459 Hamburg
Anzahl der Personen: 2
Die Komponenten eines Objektes können aus beliebigen Objekten anderer Klassen
bestehen. Sie können diese Objekte beliebig als Argumente übergeben oder als
Parameter zurückliefern.
Das Ergebnis dieser Analyse ist die obige Beschreibung mit Abbildungen der
einzelnen Klassen (Kästchen) und deren Beziehungen untereinander (Linien und
Text).
Beispiel 9.1. Wir modellieren eine Software für die Produktionsplanung einer
Firma. Das Softwaresystem besteht aus einer Eingabemaske, in die der Kunde die
Auftragsdaten und die Produktionsplanungsdaten eingibt. Die Auftragsdaten beste-
hen aus den einzelnen Artikeln. Die Produktionsmaschine und deren Konfiguration
definieren die Produktionsplanung.
Die Abb. 9.1 zeigt ein Übersichtsdiagramm der objektorientierten Analyse dieser
Planungssoftware.
ACHTUNG Jede Klasse sollte nur eine Verantwortlichkeit und nur einen
einzigen Grund zur Änderung besitzen. Teilen Sie eine Klasse auf, wenn
diese mehrere Verantwortlichkeiten hat oder gewisse Methoden nur
bestimmte Variablen benutzen. Erstellen Sie eine Klasse in der Form,
dass diese möglichst mit wenigen anderen Klassen zusammenarbeitet,
um das gewünschte Verhalten zu erreichen. Jede Klasse sollte eine über-
schaubare Anzahl von Instanzvariablen besitzen.
Die Definition eines Arrays vom Typ Klassenname erfolgt über die bereits
beschriebene for-Schleife:
Mit dieser Anweisung ist zunächst nur ein Feld von Objekten der angegebenen Län-
ge angelegt. Für jedes Element des Feldes ist ein Objekt vom Typ Klassenname
zu definieren:
obj[i] = Klassenname(parameterliste)
Das Anlegen dieser Objekte mittels Aufruf eines passenden Konstruktors erfolgt
meistens über eine for-Schleife. Der Zugriff auf eine Instanzvariable var des i-
ten Objektes funktioniert mit obj[i].var. Die Anzahl der Elemente in einem
Feldobjekt erhalten wir mit der Methode len(obj).
Beispiel 9.2. Für die Klasse Adresse und Person legen wir zwei Felder von
Adress- bzw. Personenobjekten an. Damit können wir flexibel diese Objekte an
andere Komponenten des Programms weitergeben und verarbeiten.
Ausgabe:
Anstatt eines statischen Arrays können Sie eine dynamische Datenstruktur verwen-
den:
liste = []
Mit der bereits beschriebenen Methode append() werden Objekte in das Array
hinzugefügt. Die einzelnen Objekte sind mit folgendem Schleifenkonstrukt durch-
laufbar:
for elem in liste:
...
Die Beispiele 111
Für das obige Beispiel erhalten wir den folgenden Code zum Erzeugen von
Adressen und Personen:
Ausgabe:
Müllerle Paul, Schätzlestraße 10, 78534 Schwabingen
Schmitt Ute, Katharinenstraße 6, 20459 Hamburg
Anzahl der Personen: 2
Die Beispiele
Beispiel 9.3 (Klasse Personal). Wir schreiben eine Klasse Personal zum Ver-
walten von Mitarbeitern einer Firma. Die Instanzvariablen sind ein Feld von
Personen vom Datentyp Person und ein Array von Personalnummern mit dem
Namen nummer. Die Klasse soll in der Lage sein, aus der Personalnummer das
zugehörige Gehalt zu bestimmen. Alle Personen mit einer Nummer kleiner als 100
verdienen 3000 Euro und alle anderen nur 2000 Euro pro Monat.
112 9 Wie erstelle ich objektorientierte Programme? Objektorientierte . . .
Allgemeine Erklärung:
Für das Testen dieser Klasse schreiben wir das folgende Programm:
Ausgabe:
Erich Müller, Weg 1, 12345 Stadt hat mtl. Gehalt = 3000,00 Euro
Franz Schulz, Weg 5, 12345 Stadt hat mtl. Gehalt = 2000,00 Euro
Jutta Schmid, Weg 7, 12345 Stadt hat mtl. Gehalt = 3000,00 Euro
Beispiel 9.4 (Preiskategorien und Schrauben). Ein Hersteller von Schrauben will
seine Produkte nach dem folgenden Schema einordnen:
Die Aufgabe besteht darin, den richtigen Preis einer Schraube für einen ange-
gebenen Durchmesser und eine Länge zu ermitteln. Falls eine Schraube keiner
der oben beschriebenen Kategorien angehört, erfolgt die Ausgabe der Meldung
„Unbekannter Schraubentyp“.
Wir erstellen ein objektorientiertes Programm, bei dem wir zusammengehörige
Daten und die darauf arbeitende Programmlogik zu einer Einheit zusammenfassen.
In der realen Welt existiert eine Preisgruppe für Schraubentypen, die wir mit der
Klasse Preisgruppe darstellen. Die Attribute in Form von Instanzvariablen
sind neben dem Preis, die Unter- und Obergrenzen für den Durchmesser und die
Länge. Mit dieser Modellierung erhalten wir einen gut erweiterbaren, modularen
und wiederverwendbaren Programmcode.
Allgemeine Erklärung:
• Zeile 4–9: Definition der Instanzvariablen für den unteren und oberen Durchmes-
ser (uD, oD), für die untere und obere Länge (uL, oL) und den Preis preis im
Konstruktor.
• Zeile 12–16: Prüfen, ob der übergebene Durchmesser und die Länge zu der
Preisgruppe gehören. Diese Methode vergleicht dazu die beiden Parameter mit
ihren eigenen Attributen.
• Zeile 19–20: Rückgabe des Wertes der Variable preis.
Ausgabe:
Allgemeine Erklärung:
1. Zeile 5–8: Definition der Eingabegrößen in Form von Durchmesser und Länge.
2. Zeile 12–17: Definition der einzelnen Preisgruppen durch die gegebenen Inter-
valle.
3. Zeile 20–24: Bestimmen des Preises durch Prüfen, ob die gegebenen Parameter
zu einer gegebenen Preisgruppe passen.
4. Zeile 27–30: Ausgabe des Preises durch eine formatierte Ausgabe auf der
Konsole.
Die Übungen 115
Die Zusammenfassung
Die Übungen
Aufgabe 9.1 (Klasse Schreinerei). Implementieren Sie eine Klasse Auftrag mit
der Instanzvariable artikel als Artikelliste in Form einer dynamischen Liste
mit Elementen vom Typ Schrank und einer statischen Variable mwst für den
aktuellen Mehrwertsteuersatz.1 Erstellen Sie neben einem leeren Konstruktor die
folgenden Methoden:
• add(schrank)
Hinzufügen eines neuen Schrankes.
• getAuftragswertMitSteuer()
Berechnen des Gesamtwertes des Auftrags.
• getAuftragswertOhneSteuer()
Berechnen des Gesamtwertes des Auftrags ohne die Mehrwertsteuer.
• getAuftragsliste()
Rückgabe der Auftragsliste als Zeichenkette.
1 Klasse Schrank wurde als Übung in Kap. 8 erstellt. Diese Klasse muss sich im aktuellen
Projektordner befinden.
116 9 Wie erstelle ich objektorientierte Programme? Objektorientierte . . .
• getAnzahl()
Rückgabe der Anzahl der Artikel im Auftrag.
Testen Sie diese Klasse durch eine Klasse Schreinerei mit der Definition von
mehreren Aufträgen in Form eines Arrays.
Hinweis: Beachten Sie, dass in allen Methoden wie immer als ersten Parameter
self anzugeben ist.
• getDaten()
Rückgabe der vollständigen Klausurdaten als Zeichenkette.
• getNote()
Rückgabe der Note.
Aufgabe 9.3 (Klasse Student). Implementieren Sie eine Klasse Student mit
den Instanzvariablen matrikelNr für die Matrikelnummer, nachName für den
Nachnamen, vorName für den Vornamen und klausurListe als Klausurliste
in Form einer dynamischen Liste mit Elementen vom Typ Klausur. Erstellen Sie
neben einem passenden Konstruktor noch die folgenden Methoden:
• pruefeMatrikel(matrikel)
Prüfen, ob die aktuelle Matrikelnummer mit einer übergebenen Matrikelnummer
übereinstimmt.
• addKlausur(klausur)
Hinzufügen einer neuen Klausur in die Klausurliste.
• schreibeDaten()
Ausgabe aller Klausurergebnisse und der resultierenden Durchschnittsnote.
Aufgabe 9.4 (Klasse Prüfungsamt). In einer gegebenen Datei stehen unter ande-
rem die folgenden Informationen:
• schreibeDaten()
Ausgabe der vollständigen Studentenliste.
• findeStudent(matrikel)
Gibt den Studenten mit der angegebenen Matrikelnummer zurück oder null, falls
dieser nicht vorhanden ist.
• getStudent(matrikel, vorname, nachname)
Gibt den Studenten mit der gegebenen Matrikelnummer zurück. Falls dieser
nicht vorhanden ist, wird er mit der Klasse Student mit den drei Werten
matrikel, vorname, nachname angelegt, der Studentenliste hinzugefügt
und zurückgegeben.
• schreibeNotenliste(student)
Schreiben aller Klausurergebnisse des angegebenen Studenten in eine Textdatei
mit Namen Notenliste_matrikelnummer_nachname_vorname.
• leseDaten()
Einlesen der Daten der Klausuren aus einer Datei und Zuordnen zu den Studenten
mit Hilfe der Methode getStudent().
Weiterführende Programmierkonzepte
10
Exception
Die Exception (Ausnahme) stellt ein Verfahren zum strukturierten Behandeln von
Laufzeitfehlern dar. Beispiele sind das Nichtauffinden einer Datei, eine Division
durch Null oder ein Array-Zugriff außerhalb der Grenzen. Bei dieser Fehlerbehand-
lung wird der Fehler in Form einer Exception abgefangen, an eine andere Stelle im
Programm weitergereicht und dort auf die gewünschte Art und Weise behandelt. Mit
dem Trennen von Fehlerauslöser und Fehlerbehandlung gestaltet sich der Quellcode
wesentlich übersichtlicher.
Eine Exception ist ein Objekt, das Attribute und Methoden für die Klassifikation und
Behandlung eines Fehlers enthält. In Python existieren eine große Anzahl von Ex-
ceptions, wie beispielsweise SyntaxError, ValueError oder TypeError.
Diese eingebauten Exceptions sind hierarchisch organisiert und basieren alle auf
der Basisklasse BaseException. Alle eingebauten Exception-Typen finden Sie
unter https://docs.python.org/3/library/exceptions.html.
Die Behandlung einer Exception beginnt mit dem Auftreten eines Laufzeit-
fehlers. Das Abfangen von Exceptions besteht aus zwei Blöcken, die mit den
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 119
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3_10
120 10 Weiterführende Programmierkonzepte
try:
# Überwachen der Anweisungen
except ExceptionTyp1 as Bezeichner:
# Fehlerbehandlung 1
except ExceptionTyp2 as Bezeichner:
# Fehlerbehandlung 2
except ExceptionTyp3 as Bezeichner:
# Fehlerbehandlung 3
try:
# Überwachen der Anweisungen
except (E1, E2, ..., En) as e
# Fehlerbehandlung
Jedes Exception-Objekt e besitzt die Methode args zur Rückgabe eines Fehlertex-
tes in Form eines Tupels. Mit args[0], args[1] usw. erhalten Sie die Einträge
dieses Tupels.
Ausgabe:
ValueError abgefangen: invalid literal for int()
with base 10: ’10+’
Allgemeine Erklärung: Die Methode int() löst bei einer fehlerhaften Eingabe
eine Exception vom Typ ValueError aus. Das Programm wählt in der Ausnah-
mebehandlung die erste catch-Klausel aus.
try:
# Code der Anweisungen überwacht
except ExceptionTyp1 as e:
# Code der Fehler vom ExceptionTyp1 behandelt
except ExceptionTyp2 as e:
# Code der Fehler vom ExceptionTyp2 behandelt
else:
# Code der bei keiner Exception-Behandlung
ausgeführt wird
finally:
# Code der immer ausgeführt wird
Exception-Basisklasse Exception erbt. Die Syntax für das Erstellen eines neuen
Exception-Typs sieht wie folgt aus:
class EigeneException(Exception):
def _ _init_ _(self, par1, par2, ...)
self.par1 = par1
self.par2 = par1
...
Mit Hilfe der raise-Anweisung wird eine Exception vom angegebenen Typ
geworfen:
raise ExceptionTyp(...)
Im Anschluss daran erstellen wir eine Methode division() die einen unzulässi-
gen Nenner erkennt, eine Exception vom Typ DivisionException erzeugt und
diese mit raise an die aufrufende Methode weitergibt:
Ausgabe:
3.3333333333333335
DivisionException abgefangen mit Zaehler = 10
und Nenner = 0.0
Aufzählungstyp Enum
import enum
class Typname(enum.Enum):
symbol1 = wert1
symbol2 = wert2
...
Der Zugriff auf die Parameterwerte erfolgt mit dem Typname, gefolgt von einem
Punkt und der jeweiligen symbolischen Konstante:
Typname.symbol
Alternativ kann auch der Zugriff über den Wert der symbolischen Konstante
erfolgen:
Typname(wert)
Auf den Namen kann über das Attribut name zugegriffen werden:
Typname.symbol.name
Ausgabe:
Dictionaries
Dictionaries sind Wörterbücher, mit denen es möglich ist, Daten zu gliedern und
darauf zuzugreifen. Ein Dictionary wird mit geschweiften Klammern geschrieben:
>>> auto = {’Typ’: ’VW’, ’Farbe’: ’blau’, ’Preis’: 12298}
Die Schlüssel in diesem Dictionary sind ’Typ’, ’Farbe’ und ’Preis’ mit
den Werten ’VW’, ’blau’ und 12298. Mit dem Schlüssel wird auf die Werte
zugegriffen:
>>> auto[’Typ’]
’VW’
Der Operator len(d) liefert die Anzahl der Elemente in einem Dictionary d. Mit
dem Operator del d[k] wird der Schlüssel k mit seinem Wert gelöscht. Ein leeres
Dictionary wird mit dic = {} angelegt. Dictionaries sind im Gegensatz zu Listen
nicht geordnet. Ob ein Schlüssel im Dictionary vorhanden ist, können Sie mit dem
Schlüsselwort in herausfinden:
>>> ’Farbe’ in auto
True
Dictionaries 125
Die Methode get() bekommt zwei Argumente, den Schlüssel des abzurufenden
Wertes und einen Standardwert, der zurückgegeben wird, wenn es den Schlüssel
nicht gibt:
>>> auto.get(’PS’, 90)
90
Mit der Methode setdefault() können Sie in einem Dictionary nach einem
Schlüssel suchen, sodass dieser nur dann einen Wert bekommt, wenn er noch keinen
hat. Das erste Argument ist der gesuchte Schlüssel und das zweite Argument legt
den Wert fest, falls der Schlüssel noch nicht existiert. Falls der Schlüssel vorhanden
ist, wird der bestehende Wert zurückgegeben:
>>> auto.setdefault(’PS’, 90)
90
Die Methode keys() liefert den Schlüssel, values() den Wert und items das
Schlüssel-Wert-Paar in einer for-Schleife:
for v in auto.keys():
print(v)
Ausgabe:
Typ
Farbe
Preis
for v in auto.values():
print(v)
Ausgabe:
VW
blau
12298
90
Mit Hinzufügen von list() wird das Ergebnis in einer Liste gespeichert. Mit den
bekannten Operatoren in und not in können Sie prüfen, ob ein Schlüssel oder
Wert in dem Dictionary existiert. Das Löschen eines Schlüssel-Wert-Paares erfolgt
mit der Methode pop():
>>> auto.pop(’PS’)
{’Typ’: ’VW’, ’Farbe’: ’blau’, ’Preis’: 12298}
Anhang A
Python-Schlüsselwörter
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 127
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3
128 Anhang A
Wichtige Module
Im Folgenden stellen wir kurz einige zentrale Module für Python vor, welches
das Programmieren in Python erheblich erleichtert. Weiterführende Informationen
in Form von einigen Jupyter-Notebooks können Sie sich von meiner Webseite
https://sebastiandoern.de herunterladen.
Datenstrukturen
Modul datetime
import datetime
Das Modul eignet sich sehr gut für das Verarbeiten von Kalenderdaten und kalenda-
rischen Berechnungen. Dieses Modul besitzt verschiedene Arten von Datentypen
für das Anlegen eines Datums mit einer Uhrzeit. Die einzelnen datetime-
Instanzen können miteinander verrechnet und verglichen werden.
Weitere Informationen: https://docs.python.org/3/library/datetime.html
Modul NumPy
import numpy
NumPy (Numerical Python) ist ein elementares Paket für das Manipulieren von
Arrays und für das wissenschaftliche Rechnen (z. B. Matrizenoperationen, Lösen
von Gleichungssystemen, Berechnen von Eigenwerten und Determinanten, u.v.m.).
Der Datentyp ndarray von Numpy ist ein mehrdimensionales Array, das vektorisier-
te arithmetische Operationen besitzt. Auf dem NumPy-Paket bauen viele weitere
Module in Python auf, die insbesondere in der Datenanalyse hilfreich sind. Das
NumPy-Modul ist ein zentraler Bestandteil der SciPy-Bibliothek (https://www.
scipy.org/) für die numerische Optimierung, numerische Integration, Interpolation,
Signalverarbeitung, Bildverarbeitung, FFT, numerische Integration gewöhnlicher
Differentialgleichungen und symbolischer Mathematik.
Weitere Informationen: https://docs.scipy.org/doc/numpy/reference/
Modul pandas
import pandas
Anhang A 129
Die Bibliothek Pandas basiert auf NumPy und enthält leistungsfähige Datenstruk-
turen und Funktionen zur Manipulation von Daten. Pandas enthält mit Series
(eindimensionales Array) und DataFrame (tabellarische Datenstruktur) zwei zen-
trale Datenstrukturen, die im Rahmen einer Datenanalyse sehr hilfreich sind (z. B.
statistische Auswertungen, Bearbeiten von fehlenden Daten, Kombinieren von
Datensätzen, u.v.m.).
Weitere Informationen: https://pandas.pydata.org/pandas-docs/stable/
Dateiverarbeitung
Modul docx
Drittanbietermodul: pip install python-doc
import docx
Das verwendete Dateiformat von Microsoft Word ist Open XML. Dieses Format
speichert Inhalte und Metadaten von Word-Dateien in einer XML-Datei. In Python
lassen sich Word-Dateien lesen, schreiben und bearbeiten mit dem Modul python-
docx.
Weitere Informationen: https://python-docx.readthedocs.io/en/latest/index.html#
Modul PyPDF2
Drittanbietermodul: pip install PyPDF2
import docx
Das Dateiformat PDF (Portable Document Format) ist ein plattformunabhängiges
Dateiformat für Dateien, die unabhängig vom ursprünglichen Anwendungspro-
gramm originalgetreu wiedergegeben werden. Mit dem Drittanbietermodul PyPDF2
ist es möglich Texte, Bilder und Metainformationen aus PDFs auszulesen und zu
neuen PDF-Dateien zusammenzufügen.
Weitere Informationen: https://pythonhosted.org/PyPDF2/
Modul matplotlib
import matplotlib.pyplot as plt
Visualisierungen durch Plots sind eines der wichtigsten Aufgaben in der Da-
tenanalyse, um sich einen Überblick über die Datenbasis zu schaffen und die
notwendigen Datenmodelle zu entwickeln. Python bietet mit dem Modul matplotlib
eine riesige Anzahl von möglichen Plotarten an. Die Nutzung ist einfach: Auf
die untere Webseite gehen, das passende Diagramm auswählen, den zugehörigen
Programmcode kopieren und mit den eigenen Daten verknüpfen.
Weitere Informationen: https://matplotlib.org/users/pyplot_tutorial.html
130 Anhang A
Modul pillow
Drittanbietermodul: pip install pillow
from PIL import Image
Mit dem externen Modul pillow ist in Python eine Bearbeitung von Bildern möglich,
wie beispielsweise das Beschneiden, Kopieren, Drehen oder Spiegeln von Bildern.
Mit dem Modul lassen sich auch Bilder mit verschiedenen Formen und Text
erstellen.
Weitere Informationen: https://pillow.readthedocs.io/en/stable/
Modul OpenCV
Drittanbietermodul: pip install opencv-python
import cv2
OpenCV ist eine umfangreiche Programmbibliothek mit Algorithmen für die Bild-
verarbeitung und das maschinelle Sehen. Die Bibliothek besteht aus einer großen
Anzahl von verschiedenen Filter, Klassifizierungs- und Segmentierungsverfahren,
sowie u. a. auch Algorithmen für die Gesichtserkennung und Gestenerkennung.
Weitere Informationen: https://opencv-python-tutroals.readthedocs.io/en/latest/
GUI-Automatisierung
Modul pyautogui
Drittanbietermodul: pip install pyautogui
import pyautogui
Ein zentrales Werkzeug für das Automatisieren von Routineaufgaben sind selbst
geschriebene Programme, mit denen Tastatur und Maus steuerbar sind. Diese Pro-
gramme können alles das tun, was ein Mensch am PC tun kann, wie beispielsweise
ERP-Daten eintragen, Webformulare ausfüllen oder Informationen suchen.
Weitere Informationen: https://pyautogui.readthedocs.io/en/latest/
Emails senden
Viele Routineaufgaben im Zusammenhang mit E-Mails lassen sich mit Hilfe von
Python in wenigen Zeilen automatisieren. Anwendungen sind das Herausfiltern
von Informationen aus bestimmten Standardmails, das Senden von Textpassagen
und Dokumenten an Kundenadressen oder das automatische Verschicken von
Informationsmails bei abgeschlossenen Vorgängen.
import IMAPClient
import pyzmail
Weitere Informationen: https://imapclient.readthedocs.io/en/2.1.0/
Modul math
e Eulersche Zahl e
pi Kreiszahl π
isfinite(a) Prüft, ob die Zahl a endlich ist
isnan(a) Prüft, ob die Zahl a den Wert nan hat
ceil(a) Aufrunden einer Zahl a auf die nächstgrößere ganze Zahl
floor(a) Abrunden einer Zahl a auf die nächstkleinere ganze Zahl
round(a) Kaufmännisches Runden einer Zahl a
fabs(a) Bestimmt den Betrag des Wertes von a
log(a) Logarithmus einer Zahl a
log2(a) Logarithmus einer Zahl a zur Basis 2
log10(a) Logarithmus einer Zahl a zur Basis 10
log(a,b) Logarithmus einer Zahl a zur Basis b
exp(a) Exponentialfunktion zur Basis e hoch a
pow(a,b) Potenz von a hoch b
fmod(a,b) Moduloperator a Modulo b
factorial(a) Fakultät einer Zahl a
fsum(a) Summe in der Liste/Tupel a
sqrt(a) Quadratwurzel von Zahl a
sin(a) Sinus von a im Bogenmaß
cos(a) Kosinus von a im Bogenmaß
tan(a) Tangens von a im Bogenmaß
asin(a) Arkussinus von a im Bogenmaß
acos(a) Arkuskosinus von a im Bogenmaß
atan(a) Arkustangens von a im Bogenmaß
sinh(a) Sinus Hyperbolicus von a im Bogenmaß
cosh(a) Kosinus Hyperbolicus von a im Bogenmaß
tanh(a) Tangens Hyperbolicus von a im Bogenmaß
asinh(a) Arkussinus Hyperbolicus von a im Bogenmaß
acosh(a) Arkuskosinus Hyperbolicus von a im Bogenmaß
132 Anhang A
Codierungsregeln
Sie diesen um. Benutzen Sie für Kommentare eine korrekte Grammatik mit
sorgfältig gewählten Wörtern. Eine gute Kommentierung hat die Aufgabe,
zu informieren, Absichten zu erklären, Bestandteile zu unterstreichen, vor
Konsequenzen zu warnen oder To-do-Vermerke zu erstellen. Auskommentierter
Code führt zu unnötiger Verwirrung und ist zu entfernen.
14. Teamregeln festlegen: Ein Softwaresystem besteht aus einem Satz von ähnlich
aufgebauten Quelldateien mit gleichen Formatierungsregeln. Wenn Sie in
einem Team programmieren, legen Sie die zentralen Codierungsregeln für
das Team fest: Klammersetzung, Größe der Einrückungen, Bezeichnung der
Klassen, Methoden usw. Jedes Mitglied des Teams sollte dann genau diesen
Stil benutzen, sodass der gesamte Code konsistent ist.
Fehlerbehandlung
Syntaxfehler
Syntaxfehler treten bei Fehlern im formalen Aufbau und bei falsch geschriebenen
Schlüsselwörtern auf. Diese Fehler werden vom Compiler während der Übersetzung
erkannt und das Programm wird nicht kompiliert. Der Compiler gibt in der Regel
eine Fehlermeldung, die Fehlerposition und einen erklärenden Text aus, sodass diese
Fehler in der Regel schnell zu korrigieren sind, wenn man sich in der jeweiligen
Programmiersprache gut auskennt.
Typische Syntaxfehler in der Sprache Python sind die folgenden:
Laufzeitfehler
Semantischer Fehler
Semantische oder logische Fehler liegen vor, wenn das Programm ohne Fehler
arbeitet, aber falsche Ergebnisse liefert. Ein solcher logischer Fehler kann auf einem
einfachen Tippfehler beruhen. In der Regel ist diese Art von Fehler schwierig
zu finden. Diese Fehler entstehen durch einen falschen Algorithmus und zwingen
manchmal zu einer grundlegenden Umorganisation des Programms. Fehler in der
Logik größerer Programme lassen sich durch ein klares Konzept des Programmauf-
baus vorbeugen.
Typische semantische Fehler in Python sind die folgenden:
Semantische Fehler sind teilweise sehr schwer zu finden, da das Programm läuft,
aber falsche Werte produziert. Folgende Tipps sind empfehlenswert:
Für einige Aufgaben müssen Sie externe Zusatzpakete eines Drittanbieters mit dem
Python-Tools pip nachinstallieren:
1. Suchen nach dem Ordner der Installation von Python mit der pip-Anwendung.
2. Öffnen der Eingabeaufforderung.
136 Anhang A
cd verzeichnispfad
4. Installation eines Zusatzpaktes mit dem Namen paketname mit dem Python-
Tool pip:
import paketname
#! python3
2. Anlegen einer Batch-Datei mit der Endung bat mit dem folgenden Inhalt:
@py.exe "C:\Pfad\Skriptname.py" %*
Der Pfad ist dabei durch den absoluten Pfad des Programms zu ersetzen.
3. Ausführen des Programms durch Doppelklick auf die Batch-Datei. Mit dem
Befehl pause in der Batchdatei bleibt die Konsole geöffnet.
Literatur
S. Dörn, Java lernen in abgeschlossenen Lerneinheiten (Springer, Berlin, 2019)
Al. Sweigart, Routineaufgaben mit Python automatisieren (dpunkt, Heidelberg, 2017)
J. Ernesti, P. Kaiser, Python 3 (Rheinwerk, Quincy, 2016)
T. Theis, Einstieg in Python (Rheinwerk, Quincy, 2017)
W. McKinney, Datenanalyse mit Python (O’Reilly, Sebastopol, 2017)
F. Chollet, Deep Learning MIT Python und Keras (mitp, Frechen, 2018)
A. Geron, Praxiseinstieg Machine Learning mit Scikit-Learn und TensorFlow (O’Reilly, Sebasto-
pol, 2018)
S. Raschka, Machine Learning MIT Python (mitp, Frechen, 2017)
R. Wartala, Praxiseinstieg Deep Learning (O’Reilly, Sebastopol, 2018)
D. Sarkar, Text Analytics with Python (Apress, New York, 2016)
Stichwortverzeichnis
Symbols lesen 83
? 16 schreiben 84
?? 16
D
A Datei
Abstraktion 103 Arbeitsverzeichnis 78
Aggregation 107 kopieren 79
Anaconda 3 löschen 79
Analyse, objektorientierte 107 verschieben 79
Anweisung 5, 13 Dateiverarbeitung 77
append 23 datetime 129
args 120 def 58
Ausdruck, regulärer 69 Dictionaries 124
docx 130
B
Batch-Datei 138
Bedingungsschleife 45 E
Bezeichner 27 elif 35
Block 33 else 121
bool 17 end 70
break 48 Entwicklungsumgebung, integrierte 1
Byte-Code 1 enum 123
enumerate 44
Excel
C lesen 87
Call by schreiben 86
reference 62 except 120, 121
value 62 Exception 119
class 95
close 80
Codierungsregel 134 F
compile 70 Fehler, semantischer 137
Compiler 1 finally 121
complex 17, 18 findall 73
continue 48 float 17
copy 24 Flusssteuerung 32
csv 84 for 41
CSV-Datei from 8
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2020 139
S. Dörn, Python lernen in abgeschlossenen Lerneinheiten,
https://doi.org/10.1007/978-3-658-26496-3
140 Stichwortverzeichnis
Funktion 55, 57 M
Name 58 Maschine, virtuelle 2
Parameterliste 58 Maskierungszeichen 19, 70
Signatur 58 math 17, 133
Funktionsparameter 61 matplotlib 130
Funktionszeichen 70 Matrix 24
Methode 95, 103
Klassenmethode 100
G Module 7
Getter-Methode 98 Modulo Operator 17
group 70
N
H None 59
Hallo-Welt-Programm 5 not in 23
numpy 129
I O
IDE 1 Objekt 94, 96, 107
if-Anweisung 32 Aggregation 107
IMAPClient 131 Array 109
import 8, 59 Attribute 108
in 23 Interaktion 108
init 95 Komposition 108
input 6, 19 kooperierendes 107
insert 23 Verhalten 108
Instanz 96 Zusammensetzung 105
int 17 open 80
IPython 2 OpenCV 131
openpyxl 86
Operator
J logischer 31
Jupyter-Notebook 9 relationaler 31
Ordner erstellen 78
os 77
K
Kapselung 103
Klasse 94 P
Kommentar 13 pandas 129
Komposition 108 Parameter
Konstruktor 95, 103 aktueller 57
formaler 57
pass 33
L pillow 130
Laufzeitfehler 136 pip 137
len 19, 21 print 6
list 21 private 97
List Comprehension 44 Programmierfehler 11
Liste 21 Laufzeitfehler 12
eindimensionale 21 logischer 12
kopieren 23 Syntaxfehler 12
mehrdimensionale 24 Programmiergrundsatz 10
Literal 27 Programmiersprache 13
Stichwortverzeichnis 141
R T
raise 122 Textdatei
random 18 lesen 81
range 22, 42 schreiben 80
re 70 try 120
read 81 tuple 24
readlines 81
Referenzvariable 23
remove 23 V
Restwertoperator 17 Variable 15, 27
return 56, 58 Definition 27
round 18 globale 99
Instanz 99, 103
Klasse 99, 103
S lokale 103
Schlüsselwort 6, 13 Objekt 96, 97
Schnittstelle 99
search 70
self 95 W
send2trash 79 while 45
Setter-Methoden 98 while-else 47
Shebang-Zeile 138 write 80
Shell 4
shutil 79
Sichtbarkeitstyp 97 Z
smtplib 132 Zeichenkette 19
sort 23 Zuweisungsoperator 15