Demo-PY1: Python Tutorial - Der Einstieg mit Jupyter Notebook

Diese Tutorial-Reihe des elab2go bietet einen Einstieg in die Programmiersprache Python: Variablen und Datentypen, Operatoren, Datenstrukturen für Listen und Mengen, Programmablaufsteuerung mit bedingten Verzweigungen und Schleifen, Funktionen, objektorientierte Programmierung mit Klassen. Nach einer kurzen Motivation folgt die Schritt-für-Schritt-Anleitung zur Installation der verwendeten Python-Entwicklungsumgebung und die ersten Codezeilen in Python. Hinweise und Besonderheiten zur Syntax werden an Beispiel-Codes gezeigt. Der Einstieg in Python erfolgt anhand eines Jupyter Notebook, das hier als Google Colab-Notebook verlinkt ist und direkt im Browser ausgeführt werden kann.

  Motivation

Python wird in den letzten Jahren verstärkt im Umfeld der Datenanalyse und des Machine Learning verwendet, häufig in Kombination mit der Plattform Anaconda (für Anwendungs- und Paketverwaltung) und Spyder, PyCharm, VSCode oder Jupyter Notebook als Entwicklungsplattform. Die einfache Verwendung der kostenlosen Python-Programmpakete für Datenverwaltung, -Modellierung und -Analyse Numpy, Pandas, Scikit-Learn, Keras und Tensorflow machen Python zu einer attraktiven Alternative für spezialisierte Datenanalyse-Tools wie RStudio oder MATLAB.

Warum Python? ...

Python (entwickelt um 1991 von Guido van Rossum) ist aktuell eine der meistgenutzten Programmiersprachen und bietet einen einfachen Zugang und einen mächtigen Funktionsumfang im Umfeld der Datenanalyse.
Die aktuell verwendete Version ist Python 3.8, jedoch werden je nach Anwendung auch frühere (2.x) Python-Versionen verwendet, die die Kompatibilität zu verwendeten Bibliotheken gewährleisten. Für die Verwendung von Python für Datenanalyse und Softwareentwickung sprechen eine Vielzahl von Gründen:

  • Python ist gut lesbar und verständlich, somit ist ein schneller Einstieg in die Syntax möglich.

  • Python bietet umfangreiche und kostenlose Programmbibliotheken für Datenverwaltung und Datenanalyse.

  • Python kann prozedural, objektorientiert oder funktional behandelt werden.

  • Python ist multiplattform-fähig (Windows, Mac, Linux, Raspberry Pi usw.).

... und Anaconda?

Anaconda ist eine Entwicklungplattform für die Programmiersprachen Python und R, die für wissenschaftliches Rechnen, Datenverarbeitung und Maschinelles Lernen verwendet wird. Anaconda unterstützt insbesondere die Verwaltung von Anwendungen und Paketen, die nützlich bei der Programmierung mit Python und R sind. Zu den verfügbaren Anwendungen gehören Spyder (für Python-Entwicklung), RStudio (für R-Entwicklung), Jupyter Notebooks und Jupyter Labs (für die Erstellung interaktiver Demos). Mit Hilfe der Paketverwaltung conda können Anwendungsumgebungen (engl. Environments), erstellt werden, in die jeweils zueinander passende Versionen der benötigten Pakete heruntergeladen werden.

... und Jupyter Notebook?

Jupyter-Notebook ist eine webbasierte Umgebung, die das Erstellen, Dokumentieren und Teilen von Demonstratoren unterstützt, und zwar insbesondere im Umfeld der Datenanalyse. In einem Jupyter Notebook kann man Code schreiben und ausführen, Daten visualisieren, und diesen Code auch mit anderen teilen. Das Besondere an Jupyter Notebook ist, dass der Code und die Beschreibung des Codes in unabhängige Zellen geschrieben werden, so dass einzelne Codeblöcke individuell ausgeführt werden können.
Von der Funktionalität und Arbeitsweise her ist ein Jupyter Notebook vergleichbar mit einem MATLAB Live Script, das in Demo 5 Teil 1: MATLAB Live Scripts beschrieben ist.

1 Installation der Entwicklungsumgebung

Um Python-Programme schreiben zu können, muss zunächst eine aktuelle Python-Installation von der Python-Webseite python.org heruntergeladen und installiert werden. Für die Entwicklung größerer Programme und die Durchführung von Datenanalysen sollten zusätzlich die Paketverwaltungsplattform Anaconda und die Entwicklungs- und Laufzeitumgebungen Spyder und Jupyter Notebook verwendet werden, die umfangreiche Funktionalität für Paketverwaltung, Softwareentwicklung und Präsentation bereitstellen.

Bei der Entwicklung größerer Python-Projekte, wo Syntax-Highlighting, Debugging-Funktionalität etc. wichtig sind, können weitere Entwicklungsumgebungen wie Visual Studio Code und PyCharm verwendet werden. Für den Einstieg und für kleinere Datenanalyse-Projekte, ist Anaconda + Jupyter Notebook + Spyder eine gute Startkombination.

1-1 Jupyter Notebook

Die Verwendung von Jupyter Notebook für den Einstieg hat den Vorteil, dass der Aufwand für die Installation einer Entwicklungsumgebung entfällt und man sich auf die Syntax der Sprache konzentrieren kann. Ein dokumentiertes Jupyter Notebook, das die wichtigsten Sprachkonstrukte mit Beispielen enthält, kann einfach geteilt werden, z.B. über Google Colab. Die Beispiele werden in separate Codezellen gespeichert und können in beliebiger Reihenfolge ausgeführt werden. Der Nachteil ist, dass die fortgeschrittene Funktionalität einer Entwicklungsumgebung (Syntax-Highlighting, Auto-Vervollständigung, Debuggen) hier fehlen.

Vorbereitung: Anaconda und Jupyter Notebook installieren

Die Details der Installation von Python und Anaconda sind in dem Abschnitt Vorbereitung: Installation von Python und Anaconda beschrieben.

Die Details der Verwendung von Jupyter Notebook sind in den Abschnitten Jupyter Notebook verwenden und Jupyter Notebook Widgets verwenden beschrieben, zu denen es auch YouTube-Anleitungen gibt.

Video: Jupyter Notebook

Das folgende Video zeigt, wie ein Jupyter Notebook erstellt und verwendet wird.

1-2 Spyder

Spyder ist eine Entwicklungsumgebung für Python, die vor allem in Datenanalyse-Projekten eingesetzt wird und bei der Verwendung ähnlich ist wie RStudio oder MATLAB. Die aktuelle Spyder-Version 5.0 hat im Vergleich zur vorigen Version 4.0 eine modernisierte und benutzerfreundlichere Oberfläche erhalten. Die Entwicklung in Spyder ist projekt- oder ordnerbasiert, d.h. man kann mehrere Python-Skripte entweder in einem Projekt organisieren oder als lose Sammlung in einem Ordner.

Die Benutzeroberfläche von Spyder ist in Menüleiste und drei Haupt-Panels (Editor, Interaktive Konsole, Variablen-Explorer) organisiert, die für die Entwicklung und Ausführung von Skripten verwendet werden. Weitere Panels (Files, Plots, Help) sind als Tabs in das Variablen-Explorer-Panel integriert. Die Anordnung dieser Fenster kann über das View-Menü angepasst werden.

Der Screenshot zeigt die Benutzeroberfläche von Spyder mit einem geöffneten Skript, das durch Angabe der speziellen Kommentare #%% den Code in Codezellen gliedert, die separat ausgeführt werden können.

Spyder IDE

1-3 Visual Studio Code

Visual Studio Code ist eine minimalistische Entwicklungsumgebung von Microsoft, die plattformübergreifend unterschiedliche Programmiersprachen unterstützt, unter anderem auch Python, wobei hier die entsprechende Unterstützung durch Erweiterungen dazu installiert wird. Für dies Tutorial wurde insbesondere die Jupyter-Erweiterung installiert, um den Code in Codeblöcke strukturieren und diese getrennt in der interaktiven Konsole ausführen zu können. Die Entwicklung in Visual Studio Code ist ordnerbasiert, d.h. man legt einen Ordner an, und darin zusammengehörige Skripte.

Die Benutzeroberfläche von Visual Studio Code ist in Menüleiste, Seitenleiste und drei Panels organisiert, die für die Entwicklung und Ausführung von Skripten verwendet werden. In der Seitenleiste hat man einen Schnellzugriff auf Explorer, Suche, Quellcodeverwaltung. Die Anordnung dieser Fenster kann über das Anzeigen-Menü angepasst werden.

Der Screenshot zeigt die Benutzeroberfläche von VSCode mit einem geöffneten Skript, das durch Angabe der speziellen Kommentare #%% den Code in Codezellen gliedert, die separat ausgeführt werden können.

Visual Studio Code

2 Erste Codezeilen in Python

Ein Python-Programm kann auf verschiedene Arten erstellt und getestet werden:
1. Interaktiver Modus: Der interaktive Modus erfolgt durch Eingabe der Python-Anweisungen in der Python-Befehlskonsole, dort erfolgt auch die Ausgabe. Dies ist nützlich für Tutorials, und um Programmteile zu testen. Um die Python-Befehlskonsole aufzurufen, unter Programme das Programm mit dem Namen Python auswählen.
2. Python-Skript: Größere Python-Programme sind Sammlungen von Python-Skripten, die sich in demselben Ordner befinden und ein Programmpaket bilden. Ein Python-Skript ist dabei eine Datei mit der Endung .py, das die Anweisungen des Programms enthält.
3. Jupyter Notebook: Für Tutorials oder interaktive Demos erstellen wir ein Jupyter Notebook, das die einzelnen Python-Anweisungen in Zellen strukturiert, die getrennt voneinander dokumentiert und ausgeführt werden können. Im Unterschied zum interaktiven Modus der Python-Befehlskonsole können Jupyter Notebooks besser für Demos, Lehre und Kollaboration verwendet werden.

Im Folgenden verwenden wir zunächst den interaktiven Modus, d.h. die Befehle werden direkt in der Python-Konsole eingegeben. Um die Python-Befehlskonsole mit einer bestimmten Python-Version zu öffnen, wird Anaconda aufgerufen und das entsprechende Environment ausgewählt. Durch Anklicken des Environments erhält man verschiedene Anwendungen zur Auswahl: Open Terminal, Open with IPython, Open with Jupyter Notebook. Durch Auswahl des Menüpunktes "Open with Python" wird die Python Befehlskonsole geöffnet, dort werden die Python-Befehle direkt eingegeben und es erfolgt dort auch die Ausgabe.
Hinweis: Die verschiedenen Python-Programme können auch direkt über Windows > Programme geöffnet werden, dann wird stets das Anaconda-Default-Environment verwendet.

2-1 Hello World-Programm in Python

Das Hello-World-Programm ist das kleinste lauffähige Programm in Python und gibt den Text "Hello World" auf der Konsole aus. Es verwendet für die Ausgabe die print-Funktion, die als Parameter die Zeichenkette "Hello World" erhält.
In Python geht es auch einfacher: man kann wie in MATLAB oder R einfach den Namen einer Variablen oder eines Wertes in der Konsole eingeben und die ENTER-Taste drücken, dann wird der Inhalt der Variablen bzw. der Wert ausgegeben, auch ohne print.

Python Konsole

Für die Entwicklung größerer Programme werden die Python-Befehle mit Hilfe einer Entwicklungsumgebung in ein Python-Skript gespeichert, d.h. in eine Datei mit der Endung *.py, die alle Befehle und Funktionen des Programms enthält.

2-2 Einrückungen in Python

Python verwendet Einrückungen und Leerzeichen, um Codeblöcke zu definieren, d.h. zusammengehörige Befehle anzugeben. Dies ist ein signifikanter Unterschied zu Programmiersprachen wie C oder Java, bei denen die Einrückung (engl. Indentation) im Code nur der Lesbarkeit dient und Leerzeichen vom Compiler / Interpreter ignoriert werden.
Der erste Code wird ausgeführt, beim zweiten wird eine Fehlermeldung ausgegeben, da die print-Anweisung nicht eingerückt ist. Falls wir in Zeile 4 des ersten Codes vor der print-Anweisung ein Leerzeichen einfügen, wird auch hier ein Fehler auftreten ("IndentationError: unexpected indent"), da jede Anweisung des if-Codeblocks um dieselbe Anzahl an Stellen eingerückt werden muss.

Die korrekte Einrückung ist wichtig, sobald man mit mehrzeiligen Anweisungen, d.h. Verzweigungen, Schleifen und Funktionen arbeitet, die auch mehrzeilige Codeblöcke umschließen. Für die automatische Korrektur der Einrückung kann man Programmpakete wie autopep3 verwenden, die in alle Entwicklungsumgebungen eingebunden werden können.

# Richtig: eingerückt
if 4 > 0 :
   print("Positiv!") 
   print("4 ist größer als 0") 


# Falsch: nicht eingerückt 
if 4 > 0 :
print("4 ist größer als 0") 

2-3 Kommentare in Python

Python verfügt über Kommentarfunktionen für die Dokumentation des Codes. Kommentare werden nicht vom System ausgeführt, sondern dienen der besseren Lesbarkeit und Verständlichkeit von Quellcode. Einzeilige Kommentare beginnen mit einem "#"-Symbol gefolgt von Text. Mehrzeilige Kommentare müssen am Anfang und Ende von je drei doppelten Anführungsstrichen eingerahmt werden.

# Einzeiliger Kommentar
# Noch ein Kommentar

"""
Mehrzeiliger 
Kommentar
"""

3 Variablen und Datentypen

Variablen sind benannte Speicherplätze, in denen die Daten des Programms gespeichert werden, z.B. name, jahr, x, y. Python-Variablen werden deklariert, sobald man ihnen einen Wert zuweist, z.B. x = 3, name = "HS KL". Der Datentyp (ganze Zahl, Fließkommazahl, Zeichenkette etc.) der Variablen wird automatisch durch Python vergeben und kann mit Hilfe der type-Anweisung herausgefunden werden.

# name hat den Datentyp String
name = "HS KL"   
# jahr hat den Datentyp Integer
jahr = 2019      
# isOffen ist ein Wahrheitswert
isOffen = True         
# Zuweisungen: eine pro Zeile
x = 1
y = 2
# oder mehrere in einer Zeile
x, y = 1, 2 # x = 1, y = 2
# Ausgabe 
print(name, "\n", jahr, "\n", isOffen,"\n", x, y)

3-1 Datentypen

Python verwendet intern wie die Programmiersprachen C oder Java Datentypen für ganze Zahlen (int), Fließkommazahlen (float, double), Wahrheitswerte (bool), Zeichen und Zeichenketten (str), darüber hinaus Datenstrukturen für Listen und Mengen. Die Datentypen sind in die folgenden Kategorien integriert:

Der Datentyp einer Variablen wird meist implizit bei Zuweisung eines Wertes festgelegt, er kann jedoch bei Bedarf auch explizit durch Typecasting angegeben werden, indem man den gewünschten Datentyp vor den Namen des Wertes schreibt und diesen in runde Klammern setzt, z.B. x = float(5) oder x = str("Hallo!").

# Datentyp von x 
# ist implizit int
x = 5
print(type(x)) # Ausgabe: class'int'
# Datentyp von x 
# wird auf float festgelegt
x = float(5) 
print(type(x)) # Ausgabe: class'float'

Typumwandlung wird allgemeiner verwendet, wenn der Datentyp einer Variablen sich ändern soll.

3-2 Numerische Datentypen

Es gibt in Python drei Hauptdatentypen für Zahlen: int (ganze Zahlen), float (Fließkommazahlen) und complex (komplexe Zahlen), sowie einen Datentyp Decimal für korrekt gerundete Fließpunktarithmetik. Der in Python eingebaute Datentyp float hat doppelte Genauigkeit und entspricht dem Datentyp double in C oder Java.

x = 5 # int    
pi = 3.14  # float
# Komplexe Zahl z = 2 + 3 i
z = complex(2, 3) 

# Typecasting
x = int(pi)	# x = 3
z = int("3") # z = 3

3-3 Text-Datentyp: Strings

Der Datentyp String beschreibt Texte bzw. Zeichenketten (ein Text ist eine Zeichenkette, also eine Folge von Zeichen). Mit der Angabe eines Index, der bei 0 anfängt, kann man spezifische Zeichen aus der Zeichenkette auslesen. Es können auch negative Indizes verwendet werden, dann wird die Zeichenkette vom Ende durchlaufen. Für eine Zeichenkette x erhält man mit x[0] das erste Element, mit x[-1] das letzte Element, mit x[i:j] die Zeichen von i inklusive bis j exklusiv.

Die Python-Dokumentation zu Strings beschreibt eine Reihe von Funktionen, mit denen man Zeichenketten in Python verarbeiten kann. Mit der Funktion len(x) wird die Länge einer Zeichenkette nachgefragt, also die Anzahl an Zeichen in dieser Kette. Mit der x.strip()-Anweisung besteht die Möglichkeit, Leerzeichen am Anfang und am Ende einer Zeichenkette zu löschen.

x = "Hallo!"
print(x[0]) # H
print(x[-1]) # !

print(x[1:6]) # allo!
print(x[-4:-1]) # llo

print(len(x)) # 6

x = " Hallo aus Kaiserslautern "
print(x.strip())

3-4 Boolesche Datentypen: bool

Boolesche Datentypen können nur zwei Werte annehmen, wahr oder falsch. In Python wird jede Zahl außer "0" als wahr, engl. "True", betrachtet und "0" wird als falsch, engl. "False", interpretiert. Generell wird jeder Wert mit Wahr bewertet, wenn er einen Inhalt enthält, egal ob String, Integer oder List. Boolesche Datentypen werden benötigt, wenn man auswerten muss, ob ein Ausdruck wahr oder falsch ist, zum Beispiel, wenn die Bedingung einer bedingten Verzweigung oder Schleife ausgewertet wird.

 print(6 > 5) # True
 print(6 == 4) # False 

4 Operatoren

Mit Operatoren werden Operationen an Variablen und Werten ausgeführt. Python unterteilt die Operatoren in folgende Gruppen:

Bei der Auswertung von Ausdrücken ist die Priorität der Operatoren zu beachten, ggf. sollte man Klammern verwenden.

Übersicht der Operatoren

Arithmetische Operatoren werden mit numerischen Werten verwendet, um allgemeine mathematische Operationen auszuführen.

Operator Beispiel Wirkung
Additionx + y10 + 3 # Ergebnis: 13
Subtraktionx - y10 - 3 # Ergebnis: 7
Multiplikationx * y10 * 3 # Ergebnis: 30
Divisionx / y10 / 3 # Ergebnis: 3.33
Ganzzahl-Divisionx // y10 // 3 # Ergebnis: 3
Modulo-Operatorx % y10 % 3 # Ergebnis: 1
Potenzierungx ** y10 ** 3 # Ergebnis: 1000


Zuweisungsoperatoren werden verwendet, um Variablen Werte zuzuweisen.
Bei der Zuweisung x = y wird der Wert der Variablen y (rechte Seite) der Variablen x (linke Seite) zugewiesen. Bei abkürzenden Zuweisungen wird jeweils eine Operation auf dem Wert einer Variablen ausgeführt und dieser neue Wert erneut der Variablen zugewiesen.

Operator Beispiel Wirkung
Zuweisungx = yVariable x erhält den Wert y
Abkürzende Addition x += 4 x = x + 4 # Der Wert der Variablen x wird um 4 erhöht
Abkürzende Multiplikation x *= 4 x = x * 4
Abkürzende Division x /= 4 x = x / 4
Abkürzende Ganzzahl-Division x //= 4 x = x // 4
Abkürzende Modulo x %= 4 x = x % 4

Vergleichsoperatoren und logische Operatoren werden zusammen verwendet, um Bedingungen zu formulieren, d.h. Ausdrücke, die als wahr oder falsch ausgewertet werden.

Vergleichsoperatoren verknüpfen zwei Variablen / Werte, und das Ergebnis wird als wahr oder falsch ausgewertet.

Operator Beispiel Wirkung
Gleichx == ywahr, wenn x gleich y ist
Ungleich x != y wahr, wenn x ungleich y ist
Größer x > y wahr, wenn x größer als y ist
Kleiner x < y wahr, wenn x kleiner als y ist
Größer gleich x ≥ y wahr, wenn x größer gleich y ist
Kleiner gleich x ≤ y wahr, wenn x kleiner gleich y ist


Logische Operatoren werden verwendet, um boolesche Ausdrücke zu kombinieren.
P und Q stehen für logische Ausdrücke, z.B. P = (x > 10) und Q = (x < 20).

Operator Beispiel Wirkung
Logisches UndP and QGibt wahr (1) zurück, wenn die Ausdrücke P und Q beide wahr sind
Logisches OderP or QGibt wahr (1) zurück, wenn einer der Ausdrücke P oder Q wahr ist
Logische Verneinung not P Verneint den Ausdruck P: aus wahr wird falsch, aus falsch wird wahr

Mitgliedsoperatoren prüfen die Zugehörigkeit eines Objektes zu einer Auflistung.
x steht hier für ein beliebiges Objekt, list für eine Auflistung.

Operator Beispiel Wirkung
enthalten inx in listwahr, wenn x in der Liste list enthalten ist.
nicht enthalten x not in list wahr, wenn x nicht in der Liste list enthalten ist.


Identitätsoperatoren prüfen, ob zwei Objekte auf denselben Speicherbereich zeigen.
x is y gibt wahr zurück, wenn beide Variablen dasselbe Objekt sind, d.h. auf denselben Speicherbereich zeigen.

Operator Beispiel Wirkung
Gleichx is ywahr, wenn beide Variablen dasselbe Objekt sind
Nicht gleich x is not y wahr, wenn die Variablen nicht dasselbe Objekt sind

Bitweise Operatoren (bitweises und, oder etc.) führen bitweise Operationen auf ganzzahligen Operanden aus. D.h. die Operanden werden in ihre bitweise Darstellung konvertiert, z.B. x = 5 = 0101, y = 3 = 0011, und dann wird jedes Bit im Operanden x mit dem Bit an der passenden Position im Operanden y verknüpft.

Operator Beispiel Wirkung
Bitweises Undx & y
Ergebnisbit ist 1, wenn beide Bits 1 sind
Bitweises Oder x | y Ergebnisbit ist 1, wenn mindestens eines der Bits 1 ist
Bitweises Entweder-Oder (XOR) x ^ yErgebnisbit ist 1, wenn genau eines der Bits 1 ist
Bitweises Nicht ˜ xGibt das Einerkomplement von x zurück
Shift-rightx >> n
Bits in x werden um n Positionen nach rechts geschoben.
Shift-leftx << n
Bits in x werden um n Positionen nach links geschoben.

Beispiel

x = 5 # binär: 0101 
y = 3 # binär: 0011 
print("x & y = %d" % (x & y)) # 0101 & 0011 = 0001 (1) 
print("x | y = %d" % (x | y)) # 0101 | 0011 = 0111 (7) 
print("x ^ y = %d" % (x ^ y)) # 0101 ^ 0011 = 0110 (6) 

5 Ein- und Ausgabe

5-1 Eingabe mit input()

Die Eingabe über die Python-Befehlskonsole oder in einer Jupyter Notebook-Zelle erfolgt mit Hilfe der "input()"-Funktion. Der Befehl x = input() erzeugt ein Eingabefeld, und alles, was man darin eingibt, wird in die Variable x gespeichert. Soll die Eingabe als ein bestimmter Datentyp interpretiert werden, muss sie mit Hilfe einer entsprechenden Funktion (z.B. int(), oder str()) umgewandelt werden.

Beispiel: Im folgenden Beispiel werden zwei ganze Zahlen eingegeben und zur Kontrolle formatiert wieder ausgegeben.

# Eingabeaufforderung
print("Zahl eingeben:")  
# Einlesen der Zahl
x = int(input())  
print("Noch eine Zahl eingeben:")
y = int(input())
# Formatierte Ausgabe
print("Ihre Eingabe: x = %d, y = %d" % (x, y))

Die Ausgabe nach Ausführung der Zeilen 1 bis 5 dieses Codeblocks sieht aus wie unten abgebildet. Mit Hilfe der input()-Funktion wird ein Eingabefenster erzeugt, das eine Eingabe erfordert.


5-2 Ausgabe auf die Konsole

Es gibt zwei Wege, um den Inhalt einer Variablen in Python unformatiert in die Konsole / Standardausgabe auszugeben.

Variablenname in eine neue Zeile schreiben

x = 10
y = 20
x
y

Ausgabe unterschiedlicher Variablen mit print

print("Hallo")
pi = 3.14
print(pi)
x, y = 10, 20
print(x, y)

5-3 Formatierte Ausgabe mit print() und format()

Formatierte Ausgaben, die Texte und die Inhalte von Variablen kombinieren, können in Python auf verschiedene Arten umgesetzt werden:

Das folgende Beispiel erzeugt drei Mal dieselbe Ausgabe:

# Ausgabe: x=5, y=20.5, Summe=25.50
x, y = 5, 20.5
sum = x + y
# (1) Ausgabe eines Textes mit angefügter float-Variablen
print("x=" + str(x) + " y=" + str(y) + " Summe=" + str(sum)) 
# (2) Formatierte Ausgabe mit Platzhaltern (C-Style)
print("x=%d, y=%.1f, Summe=%.2f" % (x, y, x + y))
# (3) Formatierte Ausgabe mit format
print("x={0:d}, y={1:.1f}, Summe={2:.2f}".format(x, y, x+y))

6 Bedingte Verzweigungen

Eine bedingte Verzweigung ist eine Kontrollstruktur, die festlegt, welcher von zwei (oder mehr) Anweisungsblöcken, abhängig von einer (oder mehreren) Bedingungen, ausgeführt wird. Bedingte Verzweigungen werden in Python wie in fast allen Programmiersprachen mit der if-else-Anweisung beschrieben. Das Schlüsselwort "elif" in Python ist genau wie: "Wenn die vorherigen Bedingungen nicht zutreffen, versucht es mit dieser Bedingung" und das Schlüsselwort "else" fängt alles ab, was von den vorhergehenden Bedingungen nicht erfasst wird.

x, y = 1, 4  # x = 1 und y = 4
if x > y :
  print("%d > %d" % (x, y));
elif  x == y :
  print("%d == %d" % (x, y));
else :
  print("%d < %d" % (x, y));

Komplexere Bedingungen werden mit Hilfe von Vergleichsoperatoren und logischer Operatoren formuliert.

7 Schleifen

Schleifen ermöglichen es, Anweisungen wiederholt auszuführen, und zwar so lange, wie eine Ausführungsbedingung erfüllt ist. Python verfügt über zwei Schleifenbefehle: "while"-Schleife und "for"-Schleife. Um den Kontrollfluss in Schleifen zu steuern, werden zusätzlich zu der Ausführungsbedingung die Anweisungen break und continue eingesetzt. break ermöglicht es, jederzeit aus einer Schleife auszusteigen. continue ermöglicht es, einzelne Schleifenschritte auszusetzen.

7-1 While-Schleife

Mit der "while"-Schleife werden Anweisungen ausgeführt, solange eine Bedingung wahr ist.

Beispiel: Berechne Summe 1+2+3+4+5 mit while-Schleife
Dieses Beispiel zeigt, wie eine Schleife auf die klassische Art (wie in C) geschrieben wird.

sum = 0 
i = 1 
while i <= 5: 
    print(str(i) + "+") # Ausgabe der Zählvariablen 
    sum += i # Addiere i zur Variable sum hinzu 
    i += 1 # Inkrementiere i 
print("Summe = " + str(sum)) 

Die Ausgabe nach Ausführung dieses Codeblocks sieht aus wie abgebildet. Die Anweisungen im Schleifenrumpf erzeugen die Ausgabe der zu addierenden Terme, die print-Anweisung nach der Schleife (Zeile 7) erzeugt die Ausgabe der Gesamtsumme.


7-2 For-Schleife

Mit der "for"-Schleife iteriert man über die Elemente einer Sequenz (Liste, Tupel, Menge etc.). Die Syntax der for-Schleife erfordert zwingend, dass mit Hilfe des Mitgliedsoperators "in" über die Elemente einer Sequenz iteriert werden muss. for-Schleifen wie in C, die für eine Zählvariable eine Start- und Endebedingung und eine Schrittweite festlegen, müssen in Python mit Hilfe der range()-Funktion umgeschrieben werden, wie im Beispiel unten.

Beispiel 1: Gebe Elemente einer Studierenden-Liste aus
Die Iteration über die Elemente einer Listen-Datenstruktur ist in Python die bevorzugte Art, Schleifen zu verwenden. Hierbei wird mit Hilfe des Mitgliedsoperators "in" die Mitgliedschaft eines Objektes zu einer Liste überprüft.

 studenten = ["Max Muster", "Anna Test", "John Doe"] 
 for std in studenten: 
     print("Student: " +  std) 

Beispiel 2: Berechne Summe 1+2+3+4+5 mit for-Schleife

sum = 0 
for i in range(1,6):
    print(str(i) + "+")  
    sum += i 
print("Summe = " + str(sum)) 

8 Datenstrukturen

In Python gibt es vier Datenstrukturen für Listen und Mengen: Listen (engl. lists), Tupel (engl. tuples), Mengen (engl. sets) und Dictionary (engl. dictionary). Python-Datenstrukturen können grundsätzlich unterschiedliche Datentypen enthalten, d.h. Objekte beliebigen Datentyps. Jedoch muss man bei der Durchführung von Operationen auf Elementen der Datenstruktur auf Kompatibilität achten. Bei der Auswahl einer Datenstruktur ist es wichtig, die Eigenschaften der Datenstruktur zu verstehen, da die Auswahl der passenden Datenstruktur Auswirkungen auf die Effizienz oder Sicherheit der gespeicherten Daten hat. Die angeführten Python-Datenstrukturen unterscheiden sich darin, ob sie änderbar sind (oder nicht), geordnet sind (oder nicht), und Duplikate zulassen (oder nicht).

8-1 Listen

Listen (engl. lists) sind Sammlungen von Objekten beliebigen Datentyps, die geordnet und änderbar sind. Sie erlauben doppelte Mitglieder und werden mit rechteckigen Klammern definiert. Listenelemente werden wie im Beispiel unten über den Index ausgewählt. Listen sind vergleichbar mit Arrays in C oder Java.

Beispiel: Studierende-Liste
Eine Python-Programm verwaltet eine Liste der Studierenden einer Hochschule. Mit dem Ausdruck studenten[1,3] werden alle Elemente mit Index ≥ 1 und < 3 ausgewählt (engl. "Slicing").

# Liste "studenten" 
studenten = ["Max Muster", "Anna Test", "John Doe"] 
print(studenten) # ['Max Muster', 'Anna Test', 'John Doe'] 
studenten[2] = "Jane Doe" # Zuweisung 
print(studenten[0]) # Max Muster 
print(studenten[-1]) # Jane Doe 
print(studenten[1:3]) # ['Anna Test', 'Jane Doe'] 

8-2 Tupel

Tupel (engl. tuples) sind geordnete und unveränderbare Kollektionen, die verwendet werden, um zusammen­gehörende Datensätze (engl. records) zu speichern. Sie erlauben doppelte Mitglieder und werden mit runden Klammern definiert. Die Elemente eines Tupels können über ihren Index ausgewählt werden.

Beispiel: Adressen
Ein Python-Programm verwaltet eine Liste der Standorte einer Hochschule. Da die Adressen sich nicht ändern, werden hier Tupel verwendet. Die Zuweisung in Zeile 7 erzeugt einen Fehler, da die Elemente eines Tupels nicht geändert werden können.

# Tupel "adresse"
adresse = ("HS KL", "Schoenstrasse", 11)
print(adresse) 	
print(adresse[0]) # HS KL
print(adresse[1:3]) # ('Schoenstrasse', 11)
print(adresse[-1]) 	# 11
adresse[0] = "Morlauterer Strasse" #  Fehler! 

8-3 Mengen

Mengen (engl. Sets) sind Sammlungen, die ungeordnet und nicht indiziert sind. Mengen erlauben keine doppelten Mitglieder. Da der Inhalt ungeordnet ist, kann man keinen Index für den Zugriff auf die Elemente benutzen. Eine Menge wird definiert, indem man ihre Elemente in geschweifte Klammern setzt, wie im Beispiel unten.

# Mengen (Sets)  
menge1 = {1, 2, 3, 4, "a", "b", "c"} 
menge2 = {3, 4, 5, 6, "c"} 
menge1.add(8)       # neues Element hinzufügen 
menge2.discard(6)   #  Element löschen 
print(menge1) # {1, 2, 3, 4, 8, 'a', 'b', 'c'} 
print(menge2) # {3, 4, 5, 'c'} 

Alternativ kann eine Menge mit Hilfe der Funktion set definiert werden. Im Beispiel wird zunächst eine Liste deklariert, und aus der Liste dann eine Menge mit Hilfe der set-Funktion.

list = [1, 2, 3] # Liste  
menge3 = set(list) # Menge 

Die Mengen-Datenstruktur ist eine Implementierung des mathematischen Mengenbegriffs. Man kann Mengenoperationen wie Vereinigung (engl. union), Durchschnitt (engl. intersection), Differenz (engl. difference) durchführen.

u = menge1.union(menge2) # Vereinigung) 
print(u) # {1, 2, 3, 4, 5, 8, 'a', 'b', 'c'} 
diff = menge1.difference(menge2) # Differenz 
print(diff) # {1, 2, 8, 'a', 'b'} 

Man kann die Set-Elemente mit Hilfe einer for-Schleife durchlaufen oder mit dem Komponenten-Schlüsselwort nachfragen.

8-4 Dictionaries

Dictionaries (Hashmaps) sind Sammlungen aus Schlüssel-Wert-Paaren, die ungeordnet und änderbar sind. Die Werte sind über Schlüsselwerte indexiert, die eindeutig sein müssen.

Beispiel: Telefonbuch
Eine Python-Programm verwaltet die Telefonnummern in einem Telefonbuch. Jedem Kontakt wird eine Telefonnummer zugeordnet. Schlüssel sind die Namen der Kontakte, Werte sind die Telefonnummern.

# Dictionary (Hashmap)  
telefonbuch = { 
 "Max Muster" : "0171 876654", 
 "Anna Test" : "0151 987654" 
} 
# Neuen Wert hinzufügen 
telefonbuch["John Doe"] = "0171 123456"  
print(telefonbuch) # Telefonbuch ausgeben 
# Wertaufruf mit Schlüsselwert 
annasNummer = telefonbuch.get("Anna Test")   
print(annasNummer) # 0151 987654 

9 Funktionen in Python

Eine Funktion ist ein Codeblock, der nur ausgeführt wird, wenn er aufgerufen wird. Funktionen werden einmal definiert und können dann beliebig oft aufgerufen werden. Man kann Daten oder sogenannte Parameter an eine Funktion übergeben. Eine Funktion kann auch Daten/Parameter zurückgeben. Damit eine Funktion Werte zurückgeben kann, benutzt man das Schlüsselwort "return".

Funktionen kommen auf zweierlei Arten zum Einsatz: zum einen verwendet man vorhandene Funktionen der Python-Pakete, um gewisse Aufgaben durchzuführen. Zum anderen entwickelt man eigene Funktionen für Teilaufgaben und strukturiert damit größere Programme.

9-1 Definition und Verwendung von Funktionen

Funktionen werden definiert, indem man nach dem Schlüsselwort def den Namen der Funktion, und danach, in runde Klammern gesetzt, eine Parameterliste angibt. In den nachfolgenden Zeilen stehen die Anweisungen, die zum Codeblock der Funktion gehören. Diese müssen eingerückt sein.

Funktionen werden verwendet, indem man ihren Namen angibt, gefolgt von der Liste der tatsächlichen Argumente, die in Anzahl, Reihenfolge und Datentyp mit der Parameterliste der Funktion übereinstimmen muss.

Funktion ohne Parameter

def my_func(): 
    print("Hallo!")

# Funktions-Aufrufe       
my_func()	# Ausgabe: Hallo!
my_func()	# Ausgabe: Hallo!

Funktion mit Übergabe-Parameter

def my_func(text):    
    print(text)   
# Funktions-Aufrufe:             
my_func("Hallo")	# Ausgabe: Hallo
my_func("zusammen!") # Ausgabe: zusammen!

Funktion mit Standard-Übergabe-Parameter

def my_func(text = "kein Text übergeben"): 
    print(text)

# Funktions-Aufrufe:           
my_func() # Ausgabe: kein Text übergeben
my_func("Übergebener Wert") # Ausgabe: Übergebener Wert
my_func(text = "Übergebener Wert") # Ausgabe: Übergebener Wert

Funktion mit Rückgabewert

def my_func(x):  
  return x*2 
my_func(5)

9-2 Beliebige Argumente bei Funktionen

Wenn nicht bekannt ist, wie viele Argumente an die Funktion übergeben werden, fügt man vor dem Parameternamen in der Funktionsdefinition ein * hinzu. Auf diese Weise erhält die Funktion ein Tupel von Argumenten und kann entsprechend auf die Elemente zugreifen.

Beispiel: Funktion mit beliebiger Parameterliste

def my_func(*x): 
    print(x[2]) 
my_func(4, 5, 6)	# Ausgabe: 6

9-3 Lambda-Funktionen

Eine Lambda-Funktion ist eine anonyme Funktion, die für kurze einzeilige Befehle verwendet wird und anstelle von def das Schlüsselwort lambda verwendet. Sie kann eine beliebige Anzahl von Parametern / Argumenten annehmen, aber nur einen Ausdruck (Befehl) haben. Die erste Lambda-Funktion in unserem Beispiel fügt der als Argument übergebenen Zahl den Wert 10 hinzu. Die zweite Lambda-Funktion hat zwei Argumente, a und b, die sie multipliziert.

 # Erste Lambda-Funktion:
 add = lambda a : a + 10
 # Aufruf der Funktion:
 print(add(5)) 	# Ausgabe: 15
 
 # Zweite Lambda-Funktion:
 mult = lambda a, b : a * b
 print(mult(5, 2)) 	# Ausgabe: 10

9-4 Globale und lokale Variablen

Variablen, die außerhalb einer Funktion erstellt werden, nennt man globale Variablen. Globale Variablen können innerhalb und außerhalb von Funktionen verwendet werden. Wenn man eine Variable innerhalb einer Funktion erstellt, ist diese Variable lokal und kann nur in dieser Funktion verwendet werden. Um eine globale Variable innerhalb einer Funktion zu definieren, kann man das Schlüsselwort global verwenden.

10 Klassen und Vererbung

Python ist eine objektorientierte Programmiersprache. Fast alles in Python ist ein Objekt inkl. seiner Eigenschaften und Methoden. Eine Klasse ist ein Objekt-Konstruktor zum Erstellen von Objekten der gleichen Klasse. In Python benutzt man für Klassendefinition das Schlüsselwort "class". Eine Methode einer Klasse ist eine Funktion, die innerhalb einer Klasse definiert wird und als ersten Parameter eine Referenz ("self") auf die Instanz enthält, von der sie aufgerufen wurde.

Eine Besonderheit bei der Verwendung von Membervariablen und Methoden einer Klasse in Python ist, dass bei interner Verwendung das Schlüsselwort self stets vorangestellt werden muss.

10-1 Klassen-Deklaration und Initialisierung

Python-Klassen haben eine "__init __ ()"-Methode, die implizit beim Erstellen eines neuen Klassenobjektes ausgeführt wird. Die "__init __ ()"-Methode wird verwendet, um Objekteigenschaften zu setzen oder andere Vorgänge, die beim Erstellen des Objekts erforderlich sind, durchzuführen.

Beispiel: Wir deklarieren eine Klasse Auto, mit der wir neue Auto-Objekte erzeugen wollen. Ein Auto hat die Eigenschaften Hersteller und Modell und eine Methode "ausgeben()", die die Eigenschaften des Autos zu einer Zeichenkette zusammenbaut und ausgibt.

 class Auto:
    def __init__(self, hersteller, modell):
       self.hersteller = hersteller
       self.modell = modell       
    def ausgeben(self):
        print("Hersteller: " + self.hersteller + ", Modell: " + self.modell)
   
 # Erstelle neue Klassenobjekte, gebe sie aus, und lösche sie wieder
 my_auto1 = Auto("Audi", "A3") 
 my_auto2 = Auto("BMW", "i3")
 my_auto1.ausgeben() # Ausgabe: Hersteller: Audi, Modell: A3
 my_auto2.ausgeben() # Ausgabe: Hersteller: BMW, Modell: i3
 del my_auto1
 del my_auto2  

10-2 Vererbung in Python

Vererbung ermöglicht es, Klassen zu definieren, die alle Methoden und Eigenschaften einer anderen Klasse erben. Die übergeordnete Klasse, von der geerbt wird, nennt man Basisklasse. Die untergeordnete Klasse, die von der Basisklasse Eigenschaften und Methoden erbt, nennt man Subklasse oder Kindklasse. In Python wird eine Subklasse definiert, indem man nach dem Klassennamen den Namen der Basisklasse in runde Klammern setzt.

Beispiel: Basisklasse Fahrzeug, Subklasse Auto
Wir definieren eine Basisklasse "Fahrzeug" und eine Subklasse "Auto". Die Subklasse Auto erbt die Eigenschaften und Funktionen von "Fahrzeug" und hat eine weitere Eigenschaft "farbe" sowie eine zusätzliche Methode "farbe_ausgeben()".

 # Basisklasse für Fahrzeuge
 class Fahrzeug: 
     def __init__(self, hersteller, modell):
         self.hersteller = hersteller
         self.modell = modell
     def ausgeben(self):
         print("Hersteller: " + self.hersteller + ", Modell: " + self.modell)
 # Subklasse für Autos        
 class Auto(Fahrzeug): 
     def __init__(self, hersteller, modell, farbe):
         super().__init__(hersteller, modell)
         self.farbe = farbe
     def farbe_ausgeben(self):
         print("Auto: Farbe: " + self.farbe)
  # Erstellung eines Klassenobjektes und Ausführen der Methoden
 my_auto = Auto("Audi", "A3", "rot")
 my_auto.ausgeben() # Methode geerbt von Fahrzeug-Klasse
 my_auto.farbe_ausgeben() # zusätzl. Methode aus Auto-Klasse

Beispiel: Subklasse LKW
Wir definieren eine weitere Subklasse "LKW" der Basisklasse "Fahrzeug". Die Subklasse LKW hat keine weiteren Eigenschaften, überschreibt aber die ausgeben()-Methode mit einer eigenen Definition. Das Schlüsselwort "pass" wird hier verwendet, da wir der untergeordneten Klasse keine weiteren Eigenschaften geben möchten.

In Subklassen können geerbte Methoden auch überschrieben werden, dazu wird die Methode in der Subklasse neu definiert. Hier wird die Methode "ausgeben()" so überschrieben, dass der Text "LKW" der Ausgabe vorangestellt wird.

 # Subklasse für LKWs 
 class LKW(Fahrzeug): 
     pass 
     def ausgeben(self): 
         print("LKW: Hersteller: " + self.hersteller + ", Modell: " + self.modell) 
 # Erstellung eines Klassenobjektes und Ausführen der Methoden 
 my_lkw = LKW("Mercedes-Benz", "Unimog") 
 my_lkw.ausgeben() 

Python vs. C, Java, R und MATLAB

Python ist einerseits eine Programmiersprache und kann für Softwareentwicklung verwendet werden, hat andererseits aber auch einen starken Fokus auf Datenanalyse. Im Vergleich zu den Programmiersprachen C und Java und zu den Datenanalyse-Sprachen R und MATLAB gibt es Unterschiede und Gemeinsamkeiten:

Die vollständige und detaillierte Python-Dokumentation kann auf der offiziellen Python-Webseite https://docs.python.org/3/tutorial/ nachgeschlagen werden.

YouTube-Videos

Die Verwendung der erstellten Jupyter Notebooks wird durch Videos (Screencast mit zusätzlichen Erläuterungen) veranschaulicht.

Python Tutorial: Einstieg mit Jupyter Notebook

Jupyter Notebook Widgets verwenden

Autoren, Tools und Quellen

Autor:
 Prof. Dr. Eva Maria Kiss
Mit Beiträgen von:
 Franc Willy Pouhela, M. Sc. Anke Welz
Tools: Python, Anaconda, Jupyter Notebook

Quellen und weiterführende Links:

  1. Offizielle Python Dokumentation bei python.org: https://docs.python.org/3/tutorial/
    sehr umfangreich, Nachschlagewerk, hier findet man Dokumentationen für spezifische Python-Versionen
  2. Python Tutorial bei Google Developers: https://developers.google.com/edu/python/introduction
    umfangreich, für Fortgeschrittene, verweist auf die offizielle Dokumentation
  3. Python Tutorial bei Jobvector: https://jobtensor.com/Tutorial/Python/en/Introduction
    für Einsteiger geeignet, interaktive Ausführung im Browser
  4. Datenverwaltung und -Visualisierung mit Pandas: https://www.elab2go.de/demo-py2
  5. Clusteranalyse mit scikit-learn: https://www.elab2go.de/demo-py3
  6. Predictive Maintenance mit scikit-learn: https://www.elab2go.de/demo-py4
  7. Machine Learning-Modellierung mit Keras und Tensorflow: https://www.elab2go.de/demo-py5