›  Demo-PY1: Python-Tutorial

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 von Python-Entwicklungsumgebungen 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 direkt im Browser ausgeführt werden kann.

Installation von Python und Anaconda

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 Entwicklungs- und Paketverwaltungsplattformen Anaconda, Spyder und Jupyter-Notebook verwendet werden, die umfangreiche Funktionalität für Paketverwaltung, Softwareentwicklung und Präsentation bereitstellen. Die Details der Installation von Python und Anaconda sind in 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. Das folgende Video zeigt z.B., wie ein Jupyter Notebook erstellt und verwendet wird.

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.

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 (engl. String) "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).

 >>> print("Hello World!") # Eingabezeile
 "Hello World!" # Ausgabe: Hello World!

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 unten wird richtig laufen, 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.

 # Richtig: print ist eingerückt
 if 5 > 2 :
    print("Richtig!") 
    print("5 ist größer als 2") 

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

Kommentare in Python

Python verfügt über Kommentarfunktionen für die Dokumentation des Codes. Kommentare beginnen generell mit einem "#"-Symbol gefolgt von Text. Kommentare werden nicht vom System ausgeführt, sondern dienen der besseren Lesbarkeit und Verständlichkeit von Quellcode.

 # diese Zeile ist ein Kommentar

Variablen und Datentypen

In Python werden Variablen erstellt, sobald sie einen Wert zugewiesen bekommen. Variablen werden mit einem Namen und einem Werte definiert. Anders als in C oder Java müssen sie nicht mit einem bestimmten Datentyp deklariert werden und können sogar ihren Datentyp ändern, nachdem sie festgelegt wurden.

 name = "Python 3"      # name hat den Datentyp String
 jahr = 2019            # jahr hat den Datentyp Integer
 isOffen = True         # isOffen ist ein Boolean
 
 # oder in einer Zeile:
 x, y, z = 1, 2, 3 # es gilt x=1, y=2, z=3
 
 # die Addition von Integers und Text führt zur Fehlermeldung:
 # TypeError: unsupported operand type(s) for +: 'int' and 'str' 
 x, y = 3, "Python"    
 print(x + y)

Datentypen

In Python sind standardmäßig die Datentypen in die folgenden Kategorien integriert:

• Numerische Datentypen (engl. Numeric): int, float, complex
• Boolesche Datentypen (engl. Boolean): bool
• Zeichenketten (engl. Text): str
• Binäre Datentypen (engl. Binary): bytes, bytearray, memoryview
• Auflistungen (engl. Sequences): list, tuple, range
• Mappings: dictionary
• Mengen (engl.Sets): set, frozenset

Mit Hilfe der type()-Anweisung kann der Datentyp einer Variablen nachgefragt werden. In Python kann man bei der Definition einer Variablen den Datentyp festlegen. Python verwendet wie die Programmiersprachen C oder Java Datentypen für ganze Zahlen (int), Fließkommazahlen (float, double), Wahrheitswerte (bool), Zeichen und Zeichenketten (str). Für Variablen gleicher Kategorie, wie z.B. Ganzzahlen und Gleitkommazahlen, kann der Datentyp auch durch Typumwandlung (engl. Typecasting) verändert werden.

 x = 5
 print(type(x)) # Ausgabe: < class 'int'>
 
 x = str("Hallo Welt") # Datentyp wird auf string festgelegt

Numerische Datentypen

Es gibt in Python drei Hauptdatentypen für Zahlen: int, float und complex. "int" steht für das engl. Wort Integer und beschreibt daher Ganzzahlen. "float" ist eine Gleitkommazahl und "complex" steht für eine komplexe Zahl.

 x = 5      # int
 pi = 3.14  # float
 z = complex(2, 3)  # complex, es wird die komplexe Zahl z = 2 + 3 i erstellt
 
 # Type-Casting:
 x = int(5)	     # x = 5
 pi = int(3.14)         # pi = 3
 z = int("3")	     # z = 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 kann man spezifische Zeichen aus der Zeichenkette auslesen. Die Python-Dokumentation zu Strings beschreibt eine Reihe von Funktionen, mit denen man Zeichenketten in Python verarbeiten kann.

Beispiel: 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 = "Python"     
 print(x[0]) 	# P
 
 print(x[1:3]) 	# yth
 print(x[-3:-5]) 	# noh 
     
 print(len(x))   	# 6
 
 x = " Hallo aus Kaiserslautern "
 print(x.strip()) 	# Hallo aus Kaiserslautern 

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. Bei der Programmierung passiert es häufig, dass man wissen will, ob ein Ausdruck wahr oder falsch ist, zum Beispiel, wenn die Bedingung einer Schleife ausgewertet wird. In diesem Fall wird die Bedingung als boolescher Datentyp betrachtet, und wenn das Ergebnis "wahr" ist, die Anweisungen im Schleifenrumpf ausgeführt.

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

Operatoren

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

• Arithmetische Operatoren: führen allgemeine mathematische Operationen aus.
• Zuweisungsoperatoren: weisen Variablen Werte zu.
• Vergleichsoperatoren: vergleichen zwei Werte.
• Logische Operatoren: kombinieren logische Ausdrücke, die dann als wahr oder falsch ausgewertet werden.
• Identitätsoperatoren: vergleichen Objekte
• Mitgliedsoperatoren: prüfen, ob ein Objekt in einer Sequenz liegt.
• Bitweise Operatoren: führen eine bitweise Verknüpfung der Operanden aus.

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

 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) 

YouTube-Video

Der Einstieg in die Python-Programmierung mit Jupyter Notebook wird durch folgendes YouTube-Video (Screencast mit zusätzlichen Erläuterungen) veranschaulicht.

Ein- und Ausgabe

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.

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

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.

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:

• Inhalte numerischer Variablen mit Hilfe der str-Funktion in Zeichenketten umwandeln und mit Hilfe des +-Operators verschiedene Zeichenketten aneinanderfügen.
• Formatierte Ausgabe mit Hilfe einer formatierenden Zeichenkette und der Platzhalter %d, %f, %s

• Formatierte Ausgabe mit Hilfe der String-Methode format()

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
 # Ausgabe eines Textes mit angefügter float-Variablen
 print("x=" + str(x) + " y=" + str(y) + " Summe=" + str(sum)) 
 # Formatierte Ausgabe mit Platzhaltern (C-Style)
 print("x=%d, y=%.1f, Summe=%.2f" % (x, y, x + y))
 # Formatierte Ausgabe mit format
 print("x={0:d}, y={1:.1f}, Summe={2:.2f}".format(x, y, x+y))

YouTube-Video

Die Funktionsweise der Ein- und Ausgabefunktionen in Python wird durch folgendes YouTube-Video (Screencast mit zusätzlichen Erläuterungen) veranschaulicht.

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).

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'] 

Tupel (engl. tuples) sind geordnete und unveränderbare Kollektionen, die verwendet werden, um zusammengehörende Datensätze (engl. records) zu speichern. Sie erlauben doppelte Mitglieder und werden mit runden Klammern definiert.

Beispiel: Adressen
Ein Python-Programm verwaltet eine Liste der Standorte einer Hochschule. Da die Adressen sich nicht ändern, werden hier Tupel verwendet.

 # Tupel "adresse"
 adresse = ("Hochschule Kaiserslautern", "Schoenstrasse", 11)
 print(adresse) 		# ('Hochschule Kaiserslautern', 'Schoenstrasse', 11)
 print(adresse[-1]) 	# 11
 print(adresse[1:3]) 	# ('Hochschule Kaiserslautern', 'Schoenstrasse')
 adresse[0] = "Morlauterer Strasse" #  Fehler! Das Tupel darf nicht verändert werden 

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.

 list = [1, 2, 3] # Liste  
 menge3 = set(list) # Definition aus Liste mit Hilfe der set-Funktion 

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 (Union) 
 print(u) # {1, 2, 3, 4, 5, 8, 'a', 'b', 'c'} 
 diff = menge1.difference(menge2) # Differenz der beiden Mengen 
 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.

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 

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.

Hinweis: Hier kommen auch die bereits erwähnten Einrückungen zum Einsatz, die anzeigen, dass die eingerückte Befehlszeile zu dem Code darüber gehört.

 x, y = 1, 4  # x = 1 und y = 4
 if x > y :
    print("x > y"); # wird nicht ausgeführt da x < y
 elif  x == y :
    print("x == y"); # wird nicht ausgeführt da x != y
 else :
    print("x < y"); # wird ausgeführt da x < y

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.
Hinweis: Bei Schleifen kommen die bereits erwähnten Einrückungen zum Einsatz, die anzeigen, dass die eingerückten Anweisungen zu der Schleife gehören.

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.

• Zeile 2: Initialisiere Zählvariable i mit 1
• Zeile 3: Prüfe Ausführungsbedingung i ≤ 5. Solange die Bedingung wahr ist, werden die Anweisungen des Schleifenrumpfs ausgeführt.
• Zeile 4-6: Diese Zeilen enthalten die Anweisungen des Schleifenrumpfs, die zu wiederholen sind
• Zeile 7: Ausgabe der Summe

 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.

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 iterieren 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 Elemente einer Auflistung-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

• Zeile 1: Initialisiere Variable sum mit 0
• Zeile 2: Iteriere mit der Zählvariablen i über die Sequenz {1,2,3,4,5}, die mit Hilfe des Funktionsaufrufs range(1,6) erzeugt wird.
• Zeile 3-4: Diese Zeilen enthalten die Anweisungen des Schleifenrumpfs
• Zeile 5: Ausgabe der Summe

 sum = 0 
 for i in range(1,6): 
     print(str(i) + "+") # Ausgabe der Zählvariablen 
     sum += i # Addiere i zur Variable sum hinzu 
 print("Summe = " + str(sum)) 

YouTube-Video

Die Funktionsweise der Ablaufsteuerung in Python wird durch folgendes YouTube-Video (Screencast mit zusätzlichen Erläuterungen) veranschaulicht.

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.

Hinweis: Bei Funktionen kommen die bereits erwähnten Einrückungen zum Einsatz, die anzeigen, dass die eingerückte Befehlszeile zu dem Code darüber gehört.

Definition einer Funktion

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.

Beispiel: Funktion ohne Parameter

 def my_func(): 
     print("Meine eigene Ausgabe Funktion.")

 # Funktions-Aufruf:                
 my_func()	# Ausgabe: Meine eigene Ausgabe Funktion.

Beispiel: Funktion mit Übergabe-Parameter

 def my_func(text):    
     print(text)   
 # Funktions-Aufruf:             
 my_func("Übergebener Wert")	# Ausgabe: Übergebener Wert

Beispiel: 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

Beispiel: Funktion mit Rückgabewert

 def my_func(x):  
     return x*2 
 my_func(5)	# Rückgabe des Wertes 10 

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(5, 4, 5)		# 5

Lambda-Funktion

Eine Lambda-Funktion ist eine anonyme Funktion. Sie kann eine beliebige Anzahl von Argumenten (Übergabe-Parametern) annehmen, aber nur einen Ausdruck (Befehl) haben. Unten im Code steht als erstes eine Lambda-Funktion, die der als Argument übergebenen Zahl 10 hinzufügt, oder als 2. Beispiel eine Lambda-Funktion, die Argument a mit Argument b 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

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 normalerweise 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.

Objektorientierte Programmierung

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.

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.

• Zeile 2-4: Die"__init __ ()"-Funktion setzt aktuellen Werte für hersteller und modell. Der Parameter "self" ist eine Referenz auf die aktuelle Instanz der Klasse und wird für den Zugriff auf Variablen der Klasse verwendet. Der self-Parameter muss bei allen Methoden der Klasse als erster Parameter der Parameterliste angegeben werden.
• Zeile 5-6: Die Methode ausgeben() erstellt eine Textausgabe aus den Eigenschaften des Klassenobjektes.
• Zeile 8-10: Erstelle zwei neue Klassenobjekte und gebe sie aus.
• Zeile 13-14: Lösche die Klassenobjekte. Mit dem Schlüsselwort "del" wird das Objekt zerstört und vom Speicher gelöscht.

 class Auto:
    def __init__(self, hersteller, modell):
       self.hersteller = hersteller
       self.modell = modell       
    def auto_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  

Python-Vererbung

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()".

• Zeile 2-7: Definition der Basisklasse für Fahrzeuge
• Zeile 9: Definition der Subklasse Auto.
• Zeile 10-12: In Zeile 11 wird mit "super.__init__" die Initialisierungsmethode der Basisklasse aufgerufen. Danach wird in Zeile 12 die Eigenschaft farbe gesetzt, die nur zur Subklasse gehört. D.h. mit dem Aufruf "super().__init__(hersteller, modell)" können wir auch die übergeordneten Eigenschaften initialisieren lassen.
• Zeile 13-14: Definition der Methode "farbe_ausgeben()", die nur der Subklasse gehört
• Zeile 16-18: Erstellung eines Klassenobjektes mit dem Namen my_auto. Durch Ausführen der Methoden ausgeben() und farbe_ausgeben() werden alle Eigenschaften des Klassenobjektes angezeigt.

 # 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.

 # 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:

• Einrückungen haben in Python eine syntaktische Bedeutung. Dies ist anders als in allen genannten Programmiersprachen.
• Variablen können ohne Angabe eines Datentyps verwendet werden ("dynamische Typbindung"). Dies ist anders als in C oder Java, und ähnlich wie in R oder MATLAB.
• Der Python-Interpreter hat eine interaktive Benutzerkonsole. Dies ist anders als in C oder Java, und ähnlich wie in R oder MATLAB.
• Python kann sowohl prozedural als auch objektorientiert programmiert werden. Dies ist anders als in C oder Java, und ähnlich wie in R oder MATLAB.
• Python verfügt über umfangreiche Bibliotheken für Datenverwaltung, Datenanalyse und Datenvisualisierung, wie R und MATLAB.
• Python-Klassen verfügen nicht über eine Zugriffssteuerung (private / protected / public) auf ihre Membervariablen und Methoden, d.h. alle Variablen und Methoden einer Klasse sind von außen sichtbar und verwendbar. Dies ist anders als in Java.
• Python ist von der Performance her langsamer als C oder Java. Für Echtzeitanwendungen ist C das Mittel der Wahl. Für Anwendungen mit komplexer Softwarearchitektur und hohen Sicherheitsanforderungen bietet Java die benötigte Funktionalität.

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.

Autoren, Tools und Quellen