Python Tutorial - Der Einstieg mit Jupyter Notebook

Diese Tutorial-Reihe des elab2go bietet einen Einstieg in die Programmiersprache Python. Die grundlegende Syntax wird vorgestellt (Variablen und Datentypen, Operatoren, Datenstrukturen für Listen und Mengen, Programmablaufsteuerung mit bedingten Verzweigungen und Schleifen, Funktionen, objektorientierte Programmierung mit Klassen), sowie die wichtigsten Python-Bibliotheken für Machine Learning. Nach einer kurzen Motivation folgt die Schritt-für-Schritt-Anleitung zur Installation der verwendeten Python-Entwicklungsumgebung und die ersten Codezeilen in Python. Dieses Tutorial eignet sich auch für Umsteiger, die bisher mit C-ähnlichen Sprachen oder MATLAB programmiert haben: die Gemeinsamkeiten und Unterschiede zwischen den Sprachen werden hervorgehoben und in einem letzten Abschnitt zusammengefasst.

  Motivation

Python wird aktuell verstärkt in Data Science-Anwendungen 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 Einsteiger.

Warum Python? ...

Python (entwickelt um 1991) ist eine der meistgenutzten Programmiersprachen mit vielfachen Einsatzgebieten: 1. in der Grundausbildung als erste Programmiersprache, 2. in der Lehre an Hochschulen für die didaktische Aufbereitung und das Teilen von Demonstratoren und 3. im Umfeld der Datenanalyse, wo Python einen großen Funktionsumfang und gleichzeitig einen einfachen Zugang bietet. Für die Verwendung von Python für Datenanalyse 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 oder objektorientiert verwendet werden, ist multiplattform-fähig (Windows, Linux, Raspberry Pi usw.) und kann auch in eingebetteten Systemen eingesetzt 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.

  Übersicht

Das Tutorial ist in 14 Abschnitte gegliedert, die die Python-Syntax an einfachen Beispielen erklären und aufeinander aufbauen:

Das Tutorial ist als Google Colab Notebook online verfügbar:

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 sollte zusätzlich die Data Science Plattform Anaconda mit den Entwicklungs- und Laufzeitumgebungen Spyder und Jupyter Notebook verwendet werden, die umfangreiche Funktionalität für Paketverwaltung, Softwareentwicklung und Präsentation bereitstellen. Bei der Installation von Anaconda werden die Paketverwaltungstools pip und conda gleich mit installiert, mit deren Hilfe man von der Kommandozeile aus weitere Python-Pakete verwalten kann.

Anaconda ist eine Entwicklungplattform für die Programmiersprachen Python und R, die für wissenschaftliches Rechnen und Machine Learning 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 Notebook und Jupyter Lab (für die Erstellung interaktiver Demos). Mit Hilfe der Paketverwaltung conda können Anwendungsumgebungen / Environments erstellt werden, in die jeweils zueinander passende Versionen der benötigten Pakete heruntergeladen werden.

Weitere Details der Installation von Python und Anaconda sind im Abschnitt Vorbereitung: Installation von Python und Anaconda beschrieben.

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 Visual Studio Code

Visual Studio Code (kurz: VS Code) ist eine Entwicklungsumgebung von Microsoft, die plattformübergreifend unterschiedliche Programmiersprachen unterstützt, z.B. Python, PHP, oder Java, wobei die benötigte Unterstützung jeweils durch Erweiterungen dazu installiert wird. Das Besondere an Visual Studio Code ist, dass es keine integrierte Entwicklungsumgebung mit fest eingebauter Funktionalität ist, sondern ein Gehäuse, in das man durch Erweiterungen / "Extensions" die Unterstützung für eine Vielzahl von Programmiersprachen hinzu installieren kann. Die Installation von VS Code kann entweder für einen einzelnen Benutzer erfolgen, oder als System-Installation für alle Benutzer eines Rechners. Die bevorzugte Art der Installation unter Windows ist die User-Installation, diese erfolgt in dem Benutzer-Ordner des Users und es werden keine Admin-Rechte benötigt.

Für die Python-Programmierung mit Visual Studio Code muss zunächst ein aktuelle Python-Interpreter von python.org installiert werden. Anschließend installiert man die erforderlichen Python-Extensions:
  (1) Python-Extension von Microsoft, für IntelliSense, Linting (Fehleranalyse im Code), Debugging
  (2) Jupyter-Extension, für Jupyter Notebook-Unterstützung, um den Code in Codeblöcke strukturieren und diese getrennt in der interaktiven Konsole ausführen zu können.

Visual Studio Code hat eine sehr interaktive Benutzerführung. Wenn man z.B. ein neues Python-Skript myscript.py anlegt, ohne zuvor Python und Extensions installiert zu haben, bietet VS Code von sich aus an, die fehlenden Komponenten zu installieren. D.h. man wird durch den Installationsprozess geführt, auch ohne eine explizite Anleitung befolgen zu müssen.

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 Visual Studio Code mit einem geöffneten Skript, das durch Angabe der speziellen Kommentare #%% den Code in Codezellen gliedert, die separat ausgeführt werden können. Die Entwicklung in Visual Studio Code ist ordnerbasiert, d.h. man legt einen Ordner an, und darin zusammengehörige Skripte.

Visual Studio Code

1-3 Spyder

Spyder ist eine Entwicklungsumgebung für Python, die vor allem in Datenanalyse-Projekten eingesetzt wird. Die aktuelle Spyder-Version 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
Spyder ist in Aufbau und Verwendung ähnlich wie RStudio (das Datenanalyse-Tool für die Statistik-Sprache R) oder MATLAB (die bekannte mathematische Software für Numerik und Simulation) und bietet ebenfalls einen Variablen-Editor (in MATLAB: Workspace) und eine interaktive Konsole (in MATLAB: Command Window).

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 oder Python-Modul ist dabei eine Datei mit der Endung .py, das die Anweisungen des Programms enthält und mit Hilfe von Funktionen und Klassen strukturiert werden kann. Wichtig: damit ein Verzeichnis zum Python-Paket wird, muss es eine Datei mit dem Namen __init.py__ enthalten, die leer sein kann.
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.

Die verschiedenen Python-Entwicklungsumgebungen (Jupyter Notebook, Spyder, VSCode) können entweder einzeln oder über das Paketverwaltungstool Anaconda installiert werden. Dementsprechend kann man sie entweder direkt über Windows > Programme oder aus Anaconda heraus starten.

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.

helloworld.py
    print('Hello World')
    

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.

Python-Code: Richtige Einrückung
# Richtig: eingerückt
if 4 > 0 :
    print("Positiv!") 
    print("4 ist größer als 0")
Python-Code: Falsche Einrückung
# Falsch: nicht eingerückt 
if 4 > 0 :
print("4 ist größer als 0") 
Codezelle mit Ausgabe in Jupyter Notebook
Einrückungen in Python

Einrückungen haben in Python eine syntaktische Bedeutung, sie bezeichnen einen Codeblock, d.h. eine Reihe zusammengehöriger Anweisungen. Dies ist anders als in C und Java, wo man geschweifte Klammen verwendet, um Codeblöcke zu kennzeichnen. In MATLAB wird hierfür das Schlüsselwort end verwendet, um z.B. das Ende eine for-Schleife oder einer Funktion zu kennzeichnen.

2-3 Kommentare in Python

Python verwendet unterschiedliche Arten von Kommentaren 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.

Python-Code: Kommentare
# Einzeiliger Kommentar
# Noch ein Kommentar

"""
Mehrzeiliger 
Kommentar
"""

Kommentare sind besonders wichtig, sobald größere Programme mit Funktionen und Klassen entwickelt werden. Bei der Verwendung von Funktionen sollte eine Kurzbeschreibung der Funktion, der Funktions-Parameter und des Rückgabewertes angegeben werden. Dies geschieht, indem die Kommentare in die oben erwähnten drei doppelten Anführungsstrichen nach der Funktionssignatur geschrieben werden. Tut man dies, so wird bei Aufruf des Befehls help(funktionsname) der zuvor angegebene Funktionskommentar als Hilfe ausgegeben.

Für die Erstellung professioneller Dokumentation im HTML- oder PDF-Format kann ein Dokumentations-Tool wie Doxygen eingesetzt werden. Doxygen bietet eine spezielle Syntax für Kommentare, und kann aus den Kommentaren eine Dokumentation im HTML-Format zu erzeugen.

Beispiel: Funktion in Doxygen-Syntax kommentieren
In dem folgenden Beispiel werden Wirkung und Parameter der Funktion add(x, y) kommentiert.

def add(x, y):  
  """ 
  Die Funktion berechnet die Summe zweier Eingabe-Objekte
  @param x: erster Summand
  @param y: zweiter Summand
  @return: Summe der Eingabewerte
  """
  return x + y 
help(add)
Ausgabe Kommentar für die Hilfe zu einer Funktion

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 = 1, 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.

Python-Code: Variablen und print-Funktion
# name hat den Datentyp String
name = "HS KL"   
# jahr hat den Datentyp Integer
jahr = 2022          
# Zuweisungen: eine pro Zeile
x = 1
y = 2
# oder mehrere in einer Zeile
x, y = 1, 2 # x = 1, y = 2
# Ausgabe der Variablen
print(name, "\n", jahr, "\n", x, y)
Python-Code: type-Funktion
# isPositiv wird als Wahrheitswert ausgewertet
isPositiv = (x > 0)  
# Klasse herausfinden
print(isPositiv, " hat den Datentyp ", type(isPositiv))

Variablen können in Python ohne Angabe eines Datentyps verwendet werden, dies nennt man "dynamische Typbindung". Dies ist anders als in C oder Java, und ähnlich wie in R oder MATLAB.

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:

Weiterhin gibt es das None-Objekt, dies gehört zu keinem Datentyp sondern wird verwendet, um Variablen / Objekte mit "Nichts" zu initialisieren bzw. zu prüfen, ob sie einen verfügbaren Wert haben. 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!").

Python-Code: Typumwandlung
# 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'


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.

Python-Code: Numerische Datentypen
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 String-Datentypen

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.

Python-Code: Zeichenketten
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

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 Berechnungen an Variablen und Werten ausgeführt und das Ergebnis wird einer neuen Variablen zugewiesen. Um den Abstand dist zwischen zwei Punkten (x1, y1) = (10, 2) und (x2, y2) = (4, 1) zu berechnen, wird in Zeile 3 ein Ausdruck mit Hilfe von Operatoren erstellt und einer neuen Variablen dist zugewiesen.

import math 
x1, y1, x2, y2 = 10, 2, 4, 1
dist = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
print("Abstand", dist) # Ausgabe: 6.08

Hier werden vier Operatoren verwendet: der Zuweisungsoperator =, die arithmetischen Operatoren +, - und der Potenzierungs-Operator **, sowie die math.sqrt-Funktion, um die Quadratwurzel zu berechnen. Bei der Auswertung von Ausdrücken wird eine festgelegte Priorität der Operatoren beachtet, z.B. hat Multiplikation eine höhere Priorität als Addition, in dem Ausdruck 2 * x + 1 wird zuerst x mit 2 multipliziert und dann 1 hinzuaddiert. Um die Ausführungsreihenfolge bei größeren Ausdrücken zu steuern, werden runde Klammern verwendet, was in den Klammern steht, wird zuerst ausgeführt. Python unterteilt die Operatoren in folgende Gruppen:

Die meisten Python-Operatoren sind identisch mit den gleichnamigen Operatoren in C oder Java, mit einigen Besonderheiten bei Ganzzahldivision und Potenzierung oder den Mitglieds-Operatoren in, not in, is, is not.

Ü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

Die Eingabe über die Konsole erfolgt mit Hilfe der input()-Funktion, für die Ausgabe wird die print-Funktion verwendet.

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.

Python-Code: Ein- und Ausgabe
# 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.


Die Funktion input() kann auch einen Text als Parameter erhalten, wie im nächsten Beispiel. Dann erfolgen Eingabeaufforderung und Ausgabe in derselben Zeile.

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

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)
print("x:",  x, "y:", y)
Ausgabe
Ausgabe mit print

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 (fast) 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))
Ausgabe
Formatierte Ausgabe mit print

6 Verzweigungen

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

Python-Code: if-else-Anweisung
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.

In Python müssen Bedingungen der if-else-Anweisung nicht in runde Klammern gesetzt werden, jedoch muss der if, elif, oder else-Teil der Anweisung mit einem Doppelpunkt beendet werden.

Neuere Python-Versionen (ab Python 3.10) unterstützen auch eine match-case-Anweisung, die der switch-Anweisung in C und Java ähnelt, jedoch eine erweiterte Funktionalität zum Filtern von Mustern enthält. In dem folgenden Beispiel wird eine Funktion auswahl() definiert, die mittels match-case bei den Werten 1, 2, oder 3 für den Parameter nr den jeweils passenden Text, und bei allen anderen Werten für nr eine Fehlermeldung ausgibt.

Python-Code: match-case-Anweisung
def auswahl(nr):
  match nr:
    case 1:
        print("Erste Wahl")
    case 2:
        print("Zweite Wahl")
    case 3:
        print("Dritte Wahl")
    case _:
        print("Fehler: Ungültige Wahl")
            
auswahl(1) # Erste Wahl
auswahl(2) # Zweite Wahl
auswahl(3) # Dritte Wahl
auswahl(4) # Ungültige Wahl

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 unter Verwendung einer Zählvariablen geschrieben wird.

Python-Code: while-Schleife
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, die für eine Zählvariable eine Start- und Endebedingung und eine Schrittweite festlegen (wie in C, Java oder MATLAB), müssen in Python mit Hilfe der range()-Funktion umgeschrieben werden, wie im Beispiel unten. Diese Art der for-Schleife wird in Python weniger oft benötigt, da man häufig mit Objekten arbeitet und wie im nächsten Beispiel 1 mit dem in-Operator über die Elemente einer Liste oder Menge iterieren kann.

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 der Python Standardbibliothek gibt es Datenstrukturen für Listen, Mengen und Schlüssel-Wert-Paare: Listen (engl. lists), Tupel (engl. tuples), Mengen (engl. sets) und Dictionary (engl. dictionary). Die angeführten Python-Datenstrukturen unterscheiden sich darin, ob sie änderbar sind (oder nicht), geordnet sind (oder nicht), und Duplikate zulassen (oder nicht). Z.B. sind Listen änderbar, geordnet, und lassen Duplikate zu, Mengen hingegen sind änderbar, ungeordnet und lassen keine Duplikate zu. Python-Datenstrukturen können grundsätzlich Objekte beliebigen Datentyps enthalten. Jedoch sollte man bei der Durchführung von Operationen auf Elementen der Datenstruktur auf Kompatibilität achten. Der Zugriff auf die Elemente erfolgt über Iteratoren, bei Listen und Tupeln auch über einen Index, der bei 0 anfängt und die Position des Elementes in der Liste angibt.

In Python werden außer den hier beschriebenen Listen der Standardbibliothek häufig auch die entsprechenden Datenstrukturen der NumPy-Bibliothek verwendet, die weiter unten beschrieben sind. Diese sind effizienter als die Standard-Python-Listen, sowohl was Zeit als auch was Speicherverbrauch angeht, und bieten mehr Funktionen für die Manipulation der Daten sowie für algebraische Operationen. Z.B. können NumPy-Arrays können elementweise addiert / subtrahiert werden.

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. Listen­elemente können wie im Beispiel unten über einen Index ausgewählt werden, der die Position des Elementes in der Liste angibt, oder man kann einen Iterator verwenden, um die Liste zu durchlaufen.

Beispiel: Studierende-Liste
Eine Python-Programm verwaltet eine Liste der Studierenden einer Hochschule.

Index verwenden
Hier wird der Zugriff auf die Listenelemente mittels Index verdeutlicht. 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'] 

Iterator verwenden
Der Zugriff auf die Listenelemente mittels Iterator kann implizit über die for-Schleife und den "in"-Operator erfolgen, oder indem man explizit einen Iterator erstellt und diesen durchläuft.

# Durchlaufe Liste mit Hilfe eines Iterators (implizit)
for st in studenten: 
    print(st, end=", ")
# Durchlaufe Liste mit Hilfe eines Iterators (explizit)
iterator = iter(studenten)
for st in iterator:
    print(st, end=", ")

Listen erstellen

Listen können auf unterschiedliche Weisen erstellt werden: (1) durch explizites Aufzählen der Elemente, (2) durch Verwenden einer Schleife, in der die Elemente mittels Klassen-Funktionen angefügt werden, und (3) durch List Comprehension, eine zusammengesetzte Anweisung, bei der nacheinander in einer einzigen Zeile die Definition der Listenelemente, die auszuführende for-Schleife und eine optionale Bedingung angegeben werden.

Im folgenden Beispiel wird die Liste der Zahlen 1, 4, 9, 16, 25 (also die Quadrate der ersten 5 Zahlen) auf drei unterschiedliche Arten erstellt. Als Ergebnis wird jedesmal ein Objekt des Datentyps "list" erstellt. Die Erstellung von Tupeln, Mengen und Dictionaries ist ähnlich, dort werden abhängig von der Datenstruktur andere Operationen verwendet.

(1) Explizites Aufzählen
Beim Erstellen einer Liste durch explizites Aufzählen werden die Werte kommagetrennt in eckige Klammern gesetzt. Diese Methode eignet sich nur bei kleinen Listen mit wenigen Werten.

a = [1, 4, 9, 16, 25]
print(type(a))
print(a) # Ausgabe: [1, 4, 9, 16, 25]

(2) for-Schleife und Klassen-Funktionen
Bei der Verwendung der Klassen-Funktionen wird zunächst eine leere Liste erstellt, danach werden in einer for-Schleife mit append() weitere Werte am Ende der Liste angefügt. Diese Methode eignet sich auch bei größeren Datenmengen. Mit weiteren Funktionen wie insert, remove, sort werden Elemente an einer bestimmten Stelle eingefügt, oder Elemente gelöscht, oder die Liste kann sortiert werden.

a = [] # Leere Liste
for x in range(1, 6):
    a.append(x**2) # Anfügen mit append
print(a) # Ausgabe: [1, 4, 9, 16, 25]

(3) List Comprehension
List Comprehension wird als Kurzform verwendet, um eine Liste mit abkürzenden Syntax zu erstellen: Man schreibt direkt in die eckigen Klammern die Operation, die auf jedem Element durchzuführen ist, gefolgt von der for-Schleife. Durch die Verwendung der deklarativen List Comprehension-Syntax kann man das Schreiben expliziter for-Schleifen, die ggf. noch eine Bedingung enthalten, abkürzen. Anstelle von 5 bis 6 Codezeilen kommt man mit einer einzigen Codezeile aus. Bei größeren Datenmengen sollte man anstelle von List Comprehension einen List Generator verwenden, die Syntax ist genau wie bei List Comprehension, nur mit runden anstatt der eckigen Klammern. Der Unterschied zwischen List Comprehension und List Generator besteht darin, dass Comprehension die komplette Liste sofort erstellt und im Arbeitsspeicher ablegt, während der Generator nur die gerade benötigten Elemente erstellt und damit Speicher spart.

# List Comprehension
a = [x**2 for x in range(1, 6)]
print(a) # Ausgabe: [1, 4, 9, 16, 25]
# List Generator
a = (x**2 for x in range(1, 6))
print(a) # so keine Ausgabe! - Schleife erforderlich
# Comprehension mit Bedingung 
a = [x**2 for x in range(1, 6) if x % 2 == 0]
print(a) # Ausgabe: [4, 16]

Listen-Operationen

Liste sind als eine Klasse "list" implementiert, die über eine Reihe von Operationen verfügt, mit deren Hilfe man Listen bearbeiten kann. Wichtige Listenoperationen sind z.B. append - am Ende anfügen, insert() - an bestimmter Position einfügen, pop() - Element an bestimmter Position zurückgeben und aus der Liste entfernen, remove() - Element entfernen, clear() - Liste leeren, sort() - Liste sortieren.

a = [] # Leere Liste
# Elemente anfügen mit append
for i in range(1, 6):
    a.append(i**2) 
# Wert 100 einfügen nach Index 2 mit insert
a.insert(2, 100) 
a.sort() # Sortieren
a.reverse() # Reihenfolge umkehren
print(a) # Ausgabe: [100, 25, 16, 9, 4, 1]

Listen konvertieren

Eine häufig benötigte Funktionalität im Zusammenhang mit Listen ist das Umwandeln einer Liste in einen String, dies kann z.B. mit Hilfe der join-Funktion erreicht werden. Im folgenden Beispiel haben wir eine Liste mit Studenten-Namen, die wir für die Ausgabe in eine Zeichenkette umwandeln wollen, dabei soll als Trennzeichen für die einzelnen Elemente ein Semikolon verwendet werden.

Python-Code: Liste in String umwandeln mit join
stud_list = ["Max Muster", "Anna Test", "John Doe"]
print("Liste:\n", stud_list)
stud_string = ';'.join([str(item) for item in stud_list])
print("String:\n", stud_string)
Ausgabe Liste in String umwandeln mit join

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.

Beispiel: Menge aus Liste erzeugen mit set
list = [1, 2, 3] # Liste  
menge3 = set(list) # Menge 

Die Mengen-Datenstruktur ist eine Implementierung des mathematischen Mengenbegriffs und unterstützt Mengenoperationen wie Vereinigung (engl. union), Durchschnitt (engl. intersection), Differenz (engl. difference).

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 sind Sammlungen aus Schlüssel-Wert-Paaren, die ungeordnet und änderbar sind. Die eigentlichen Datenwerte ("values") sind über eindeutige Schlüsselwerte ("keys") indexiert. Dictionaries sind eine besonders effiziente Art der Datenspeicherung, allerdings sind die Daten nicht direkt sortierbar. Ist eine Sortierung der Daten in einem Dictionary erforderlich, z.B. nach Schlüssel, muss das Dictionary zunächst in eine Liste überführt werden, die dann sortiert werden kann.

Beispiel: Dictionary "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. In diesem Beispiel-Dictionary können keine zwei Personen mit demselben Namen gespeichert werden!

# Dictionary = Schlüssel-Wert-Paare
telefonbuch = { 
 "Max" : "0171 876654", 
 "Anna" : "0151 987654" 
} 
# Neue Schlüssel-Wert-Paare hinzufügen 
telefonbuch["John"] = "0171 123456"  
telefonbuch.update({"Jane": "0171 123456"})  
print(telefonbuch) # Telefonbuch ausgeben 
# Wert über Schlüssel abfragen 
annasNummer = telefonbuch.get("Anna")   
print(annasNummer) # 0151 987654 
telefonbuch_sortiert = dict(sorted(telefonbuch.items()))
print(telefonbuch_sortiert) 

Python-Dictionaries verfügen über einen Satz eingebauter Funktionen, mittels deren man Elemente hinzufügen, ändern und löschen kann, sowie die Schlüssel oder Werte als Listen extrahieren, insbesondere: mydict.update({key_value_pairs}) - Schlüssel-Wert-Paare hinzufügen, mydict.get(key) - Wert zu gegebenem Schlüssel holen, mydict.items() - Schlüssel-Wert-Paare als Liste zurückgeben, mydict.keys() - Schlüssel zurückgeben, mydict.values() - Werte zurückgeben.

Python-Dictionaries können weiterhin über eine Reihe von Funktionen aus Listen erzeugt und in Listen konvertiert werden. Dies ist z.B. dann nützlich, wenn die gespeicherten Daten sortiert oder anderweitig nachbearbeitet werden müssen.

Beispiel: Dictionary "Telefonbuch" aus Listen erzeugen
In diesem Beispiel wird das Dictionary "Telefonbuch" aus zwei Listen mit Hilfe zweier Funktionen erzeugt: zip() verknüpft paarweise die Elemente zweier List-Iteratoren, dict() erzeugt daraus ein Dictionary. Anschließend werden das Dictionary selber sowie die Schlüssel- und Werte als Liste ausgegeben.

keys = ['Max Muster', 'Anna Test', 'John Doe']
values = ['0171 876654', '0151 987654', '0171 123456']
telefonbuch = dict(zip(keys, values))
print(telefonbuch)
print(list(telefonbuch.keys()))
print(list(telefonbuch.values()))

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". In Python enthält die Parameterliste üblicherweise eine festgelegte Anzahl an Parametern, es gibt jedoch auch die Möglichkeit, mittels *args oder **kwargs eine variable Anzahl an Parametern zu übergeben (siehe Abschnitt 9-2).

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 Selbstdefinierte 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 bzw. aufgerufen, indem man ihren Namen angibt, gefolgt von der Liste der tatsächlichen Argumente, die in Anzahl und Reihenfolge mit der Parameterliste der Funktion übereinstimmen muss.

Funktion ohne Parameter
Die Funktion mit dem Namen my_func() gibt bei jedem Aufruf den Text "Hallo" auf der Konsole aus. Die Parameterliste ist leer, d.h. zwischen den runden Klammern steht nichts.

# (1) Funktion definieren 
def my_func(): 
    print("Hallo!")

# (2) Funktion verwenden       
my_func()	# Ausgabe: Hallo!
my_func()	# Ausgabe: Hallo!

Funktion mit Übergabe-Parameter
Die Funktion mit dem Namen my_func() gibt ihre beiden Parameter auf der Konsole aus, getrennt durch ">>". Jeder der Parameter darf ein beliebiges Objekt sein. Der Funktionsaufruf in Zeile 9 führt zu der Fehlermeldung "TypeError: my_func() missing 1 required positional argument: 'text'", da für den zweiten Parameter kein Wert übergeben wurde.

# (1) Funktion definieren 
def my_func(nr, text):    
    print(nr, '>>', text)   
# (2) Funktion verwenden     
my_func(1, "Hallo")	# Ausgabe:  1 >> Hallo
my_func(2, "zusammen!") # Ausgabe: 2 >> zusammen! 
my_func(3, [1,2,3,4]) # Ausgabe: 3 >> [1, 2, 3, 4]
my_func("X", 4) # Ausgabe: X >> 4
my_func(4) # Fehler! Das zweite Argument fehlt

Funktion mit Standard-Übergabe-Parameter

# (1) Funktion definieren 
def my_func(text = "kein Text übergeben"): 
    print(text)

# (2) Funktion verwenden   
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
Eine Funktion kann auch Daten/Parameter als Rückgabewert zurückliefern, diese können in der aufrufenden Funktion in Berechnungen oder Ausgaben weiter verwendet werden. Damit eine Funktion einen Wert zurückgibt, wird das Schlüsselwort return verwendet.

Beispiel 1
Beispiel 1 definiert die Funktion myfunc(), die das Doppelte des Parameters x zurückgibt.

# (1) Funktion definieren 
def my_func(x):  
  return x*2 
# (2) Funktion verwenden   
print(my_func(4)) # Ausgabe: 8
print(my_func(5)) # Ausgabe: 10

Beispiel 2
Beispiel 2 zeigt, wie eine benutzerdefinierte Funktion f(x,y) = sin(x)*exp(-y) definiert wird. Die Parameter x und y müssen reelle Werte sein. Die Funktion funktioniert nicht für Parameter x, y, die Listen sind, also erzeugt f(list1, list2) einen Fehler. Wenn eine Funktion in Python Listenparameter akzeptieren soll, muss sie zuerst mit der NumPy-Function vectorize in eine vektorisierte Form umgewandelt werden.

# Definiere die Funktion f
from numpy import pi, sin, exp
def f(x, y) :
    return sin(x)*exp(-y)
# Verwende die Funktion f
z = f(pi/4, 1); print(z)
# Verwende vektorisierte Version der Funktion f
fvec = np.vectorize(f)
z = fvec([pi/4, pi/2], [1, 2]); print(z)
Funktionen / Methoden in Python unterscheiden sich in einigen Punkten von Funktionen in C. Eine Funktion kann z.B. nicht nur einzelne Werte zurückgeben, sondern auch mehrere Werte als Tupel. Dafür wird die Parameterübergabe als Referenz wie in C nicht unterstützt, und der Datentyp der übergebenen Argumente wird nicht überprüft, der Programmierer muss selber für korrekte Parameterübergabe sorgen.

9-2 Funktionen mit variabler Parameterliste

Wenn nicht bekannt ist, wie viele Argumente an die Funktion übergeben werden, fügt man vor dem Parameternamen in der Funktionsdefinition ein * hinzu, d.h. man verwendet den Unpacking-Operator (*), um den Parameter "auszupacken". Auf diese Weise erhält die Funktion ein Tupel von Argumenten und kann entsprechend auf die Elemente zugreifen. Die variablen Parameter bezeichnet man üblicherweise mit *args, das ist jedoch lediglich eine Namenskonvention. Für noch mehr Flexibilität können Schlüsselwertargumente mit dem Bezeichner **kwargs verwendet werden.

Beispiel: Funktion mit variabler Parameterliste
Die Funktion anzahl_arg() hat eine variable Parameterliste und gibt die Anzahl ihrer Parameter aus. Der Funktionsaufruf in Zeile 5 erzeugt die Ausgabe 1, da die Funktion hier nur ein Argument, nämlich die Liste [1, 2, "Los"], erhält. Der Funktionsaufruf in Zeile 6 erzeugt die Ausgabe 2, da die Funktion hier zwei Argumente, nämlich die Liste [1, 2] und den String "Los!" erhält. Der Funktionsaufruf in Zeile 7 erzeugt die Ausgabe 3, da der Funktion hier drei Argumente, nämlich die Zahlen 1 und 2 sowie den String "Los!" übergeben werden. Würde man den * vor dem Namen des Parameters weglassen, könnte hier nur ein einziger Parameter übergeben werden, z.B. ein Objekt oder eine Liste.

# (1) Funktion definieren
def anzahl_arg(*args): 
    return len(args)
# (2) Funktion verwenden
print(anzahl_arg([1, 2, "Los!"])) # Ausgabe : 1 
print(anzahl_arg([1, 2], "Los!")) # Ausgabe: 2
print(anzahl_arg(1, 2, "Los!")) # Ausgabe: 3
Möchte man in ein und derselben Funktion sowohl feste als auch variable Parameter verwenden, ist die Reihenfolge my_func(fargs, *args, **kwargs).

9-3 Lambda-Funktionen

Eine Lambda-Funktion ist eine spezielle Art von 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":
 add = lambda a : a + 10
 # Aufruf der Funktion:
 print(add(5)) 	# Ausgabe: 15
 
 # Zweite Lambda-Funktion "mult":
 mult = lambda a, b : a * b
 # Aufruf der Funktion:
 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, deren komplette Funktionalität über Klassen abgebildet ist. Die Strukturierung von Python-Skripten mittels Klassen ist nicht zwingend erforderlich und bei kleineren Programmen auch nicht notwendig. Bei der Entwicklung größerer Software-Komponenten, die ggf. auch graphische Benutzeroberflächen enthalten, kommt man auch in Python an Klassen und Vererbung nicht vorbei.

Was bedeutet objektorientierte Programmierung (OOP)? Objektorientierte Programmierung (OOP) ist ein Modell bzw. Design höherer Programmiersprachen, das ein Programm mittels Objekten strukturiert, die Attribute und Aktionen besitzen. Eine Klasse ist ein Objekt-Konstruktor zum Erstellen von neuen Objekten einer Klasse, diese nennt man auch die Instanzen der Klasse. Attribute einer Klasse sind Variablen, die zu der Klasse gehören und die Eigenschaft der Objekte beschreiben. Methoden einer Klasse sind Funktionen, die innerhalb einer Klasse definiert werden und Aktion beschreiben, die auf den Daten der Klasse durchgeführt werden. OOP ermöglicht eine höhere Abstraktion bei der Programmierung, die Kapselung zusammengehörender Attribute und Aktionen, sowie die Wiederverwendbarkeit von Code: durch Vererbung kann eine Subklasse die Attribute und Methoden einer Basisklasse erben.

Klasse eines Python-Objektes herausfinden
Die Klasse eines Python-Objektes kann mit Hilfe der type-Anweisung herausgefunden werden. Wenn man mit type() den Typ einer Zahl, einer Zeichenkette, oder einer Liste ausgibt, wird die passende Klasse ausgegeben, mit deren Hilfe das entsprechende Objekt erzeugt wurde.

zahl = 1.23
text = 'Hallo'
mylist = [1, 4, 9, 16, 25]
print("Python-Objekte und ihre Klassen: ")
print(type(zahl)) # Ausgabe: <class 'float'>
print(type(text)) # Ausgabe:  <class 'str'>
print(type(mylist)) # Ausgabe:  <class 'list'>

10-1 Klassen in Python deklarieren

In Python benutzt man für die Definition einer neuen Klasse das Schlüsselwort class, danach wird der Name der Klasse angegeben, gefolgt von Doppelpunkt, und danach eingerückt die Methoden der Klasse. Eine Methode einer Klasse ist eine Funktion, die innerhalb dieser Klasse definiert wird und als ersten Parameter einen Verweis namens self auf die Instanz enthält, von der sie aufgerufen wurde. Man unterscheidet zwischen Instanzmethoden, die zu einer Instanz der Klasse gehören (also zu einem Objekt der Klasse) und Klassenmethoden, die der Klasse im allgemeinen gehören und nur sparsam eingesetzt werden sollten.

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

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

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

11 Python-Pakete

Python-Pakete sind Klassen- und Funktionsbibliotheken, d.h. Gruppierungen von Klassen und Funktionen für definierte Einsatzgebiete. Python-Pakete kommen auf zweierlei Arten zum Einsatz: zum einen verwendet man Funktionen vorhandener Pakete, um gewisse Aufgaben durchzuführen. Zum anderen entwickelt man eigene Funktionen für Teilaufgaben und strukturiert damit größere Programme.

11-1 Python-Pakete verwenden

Python verfügt über eine eingebaute Standardbibliothek (Python Standard Library), die direkt nach der Installation verfügbar sind, und viele grundlegende Funktionen schon enthält (mathematische Funktionen, Textverarbeitung, Systemfunktionen, Dateizugriff, Verschlüsselung etc.) Darüber hinaus gibt es eine Reihe von spezialisierten Python-Bibliotheken, die Funktionalität für Datenanalyse und Machine Learning oder Kryptografie Verfügung stellen. Um ein spezielles Python-Paket verwenden zu können, muss es zuvor installiert werden.

Wie werden Python-Bibliotheken bzw. Python-Pakete installiert?
Python-Bibliotheken, die nach der Installation nicht schon dabei sind, können über die Paketverwaltungstools pip und conda einfach hinzu installiert werden. Das Paket­verwaltungstool pip funktioniert nur mit Python-Modulen, das erweiterte Paket­verwaltungs­tool conda kann auch verwendet werden, um Module in anderen Programmiersprachen zu laden, z.B. in der statistischen Programmiersprache R.

Die beiden Tools werden über die Python-Konsole bedient. Die Syntax der Befehle ist ähnlich, z.B. pip list (install, uninstall, ...) oder conda list (install, uninstall, ...). Zunächst die Verwendung von pip an einem Beispiel: Unten werden alle installierten Pakete angezeigt und danach werden das Paket Pandas sowie die neueste Version des Pakets Numpy installiert.

pip list
pip install pandas
pip install numpy --update

Conda ist ein Paketverwaltungs-Programm, mit dessen Hilfe man Anwendungsumgebungen (engl. Environments) erstellen, aktivieren / deaktivieren und Pakete installieren und aktualisieren kann. Die wichtigsten conda-Befehle sind conda create, conda activate, conda install, conda update und conda deactivate. Um zum Beispiel eine Anwendungsumgebung mit dem Namen ML zu erstellen und in diese eine spezielle Zusammenstellung von Programmpaketen zu installieren, werden folgende Befehle verwendet:

conda create --name ML
conda activate ML
conda install pandas
conda install tensorflow
conda install keras
conda deactivate ML

Wie werden Python-Bibliotheken bzw. Python-Pakete importiert?
Um ein Python-Paket in einem eigenen Skript verwenden zu können, wird es mittels import-Befehl importiert, dabei hat es sich bewährt, einen abkürzenden Alias-Namen zu vergeben, z.B. np für numpy, oder plt für matplotlib. Es können auch einzelne Funktionen importiert werden, anstelle eines kompletten Pakets. In dem folgenden Beispiel werden die Pakete NumPy und Matplotlib jeweils mit einem Alias-Namen importiert, dieser muss den Funktionsaufrufen dann vorangestellt werden, z.B. np.linspace(), oder plt.plot().

import numpy as np  
import matplotlib.pyplot as plt
x = np.linspace(0,10,40)  # x-Werte
y = np.sin(x); # y-Werte
# Plot der Sinus-Funktion
plt.plot(x, y,'r*', label='sin');  

11-2 Python-Pakete erstellen

Größere Python-Programme können in Pakete (engl. packages) strukturiert werden. Ein Paket ist einfach ein Verzeichnis, das eine Datei __init__.py enthält, die leer sein kann, sowie eine beliebige Anzahl an Python-Modulen, die zusammengehörige Funktionen und Klassen gruppieren. Nachdem ein Python-Paket erstellt wurde, können die darin definierten Klassen und Funktionen in anderen Python-Skripten verwendet werden, indem man entweder das komplette Paket oder nur einzelne Module oder Klassen / Funktionen importiert.

Beim Importieren von Paketen / Modulen / Klassen / Funktionen wird die Punkt-Notation verwendet, um die Zugehörigkeit zu kennzeichnen. z.B. paket.modul.klasse. Es können auch Alias-Namen für Pakete und Module vergeben werden, dies sind Kurznamen, die die Verwendung im Code vereinfachen. Valide Syntax ist z.B.
import paket as pk
import paket.modul as md
from paket.modul import klasse as kl

Als Beispiel erstellen wir ein Package mit dem Namen mypkg, das zwei Module enthält, module1.py und module2.py. Das Modul module1.py enthält die Definition zweier Funktionen myfunc1 und myfunc2, das Modul module2 die Definition der Klasse Auto, die wir in Abschnitt 10 vorgestellt haben. Die Verzeichnisstruktur sieht wie abgebildet aus:

Paketverzeichnis mypkg
Paketverzeichnis mypkg
mypkg/module1.py
def my_func1(text):        
    print(text)
def my_func2(x):
  return x*2


mypkg/module2.py
class Auto:
  def __init__(self, herst, modell):
     self.herst = herst
     self.modell = modell
  def ausgeben(self):
     print("Hersteller: ...")

Zum Testen der Paketverwendung erstellen wir ein Test-Skript pkg_test.py, das sich im übergeordneten Verzeichnis relativ zu dem Verzeichnis mypkg befindet, und importieren die Module module1 und module2 mit Alias-Namen m1 und m2.
Der Befehl import mypkg.module1 as m1 importiert das Modul module1 aus dem Paket mypkg mit dem Namen Alias-Namen m1. Dies bedeutet, dass wir im Code die Funktionsaufrufe in der Form m1.myfunc1() angeben müssen.

pkg_test.py
import mypkg.module1 as m1
m1.my_func1("Hallo!")
print(m1.my_func2(10))
import mypkg.module2 as m2
my_auto1 = m2.Auto("Audi", "A3") 
my_auto2 = m2.Auto("BMW", "i3")
my_auto1.ausgeben() # Ausgabe: Hersteller: Audi, Modell: A3
my_auto2.ausgeben() # Ausgabe: Hersteller: BMW, Modell: i3

11-3 Python-Pakete für Datenanalyse

Zu den wichtigsten Python-Bibliotheken für Datenanalyse und Datenvisualisierung gehören:


11-4 NumPy

NumPy ist eine Python-Bibliothek für Datenauswertung und bietet Unterstützung für die Erzeugung, Umformung und statistische Auswertung von Arrays und Zufallszahlen. Mit NumPy können Arrays erstellt, mit Default-Werten initialisiert und extrahiert werden, man kann elementweise Operationen an Arrays durchführen, Elemente sortieren, suchen, zählen und Array-Statistiken berechnen. NumPy bietet auch mathematische Konstanten und Funktionen (pi, sin, cos ...).

NumPy verwenden: 1D und 2D-Arrays
Im folgenden Beispiel wird die Erzeugung von 1D und 2D-Arrays gezeigt. Zunächst werden zwei eindimensionale NumPy-Arrays x1 und x2 mit jeweils vier Elementen erstellt: x1 aus einer Liste über den Array-Konstruktor np.array(), x2 als Zahlenfolge (Start: 1, Ende: 8, Schrittweite 2) über die Funktion arange(). Mit Hilfe des Ausdrucks sum = x1 + x2 wird die elementweise Summe der beiden NumPy-Arrays berechnet. Die elementweise Summe zweier NumPy-Arrays kann alternativ auch mit sum = np.add(x1, x2) berechnet werden. Danach werden zwei zweidimensionale Arrays a1 und a2 erstellt: eine 2x2 Matrix a1 mit den Elementen 1, 2, 3, 4, und a2 als 2x2 Einheitsmatrix mit Hilfe der Funktion eye(). Für die beiden 2D-Arrays wird schließlich mittels prod = a1 * a2 das elementweise Produkt berechnet.

Python-Code: NumPy verwenden
import numpy as np
# Eindimensionale Arrays
x1 = np.array([1, 2, 3, 4])
x2 = np.arange(1, 8, 2) # 1, 3, 5, 7
sum = x1 + x2 # Elementweise Summe
print('x1:', x1, '\nx2:', x2, '\nsum:', sum)
# Zweidimensionale Arrays
a1 = np.array([[1, 2], [3, 4]], )
a2 = np.eye((2))
prod = a1 * a2 # Elementweises Produkt
print('a1:\n', a1, '\na2:\n', a2, '\nprod:\n', prod)
Ausgabe: NumPy verwenden NumPy 1D und 2D-Arrays
Häufig verwendete Funktionen für die Erstellung von NumPy-Arrays sind: np.array() - erzeuge Array aus Liste, np.zeros() - erzeuge Array und befülle es mit 0-Werten, np.ones() - erzeuge Array und befülle es mit 1-Werten.
Häufig verwendete Funktionen für die Umformung von NumPy-Arrays sind: np.reshape() - ändere die Dimensionen des Arrays, np.transpose() - transponiere Array.

NumPy Arrays vs. Python Listen
Was ist also der Unterschied zwischen NumPy Arrays und Listen der Python Standardbibliothek? NumPy-Arrays haben eine feste Größe, enthalten Elemente desselben Datentyps und unterstützen effizient elementweise Operationen und eine Vielzahl statistischer Funktionen. Sie werden daher bevorzugt im Umfeld der Datenanalyse eingesetzt.

Im folgenden Beispiel werden verschiedene Arten der Summenbildung bzw. Addition gezeigt: der "+"-Operator ist jeweils abhängig von dem Datentyp der Operanden mit einer anderen Funktionalität belegt.
- Addiert man zwei Python-Listen, so ist das Ergebnis eine neue Liste, in der die Elemente aneinandergefügt wurden.
- Addiert man zwei NumPy-Arrays, so ist das Ergebnis ein neues Array, das die elementweise addierten Elemente enthält. Die elementweise Addition kann auch mit Python Listen durchgeführt werden, jedoch komplizierter, dann muss eine Schleife oder die sogenannte List Comprehension verwendet werden, wie im Beispiel unten.

Python-Code: Python Listen vs. NumPy Arrays
import numpy as np
# Zwei Python Listen
list1 = [1, 2, 3, 4] 
list2 = [5, 6, 7, 8]
# Konvertiert in NumPy Arrays
arr1 = np.array(list1) # NumPy Array [1 2 3 4] 
arr2 = np.array(list2) # NumPy Array [5 6 7 8] 
# Verschiedene Arten der Addition / Summenbildung
print("Addiere Python Listen: Aneinanderfügen!")
sum = list1 + list2
print(sum) # [1, 2, 3, 4, 5, 6, 7, 8]
print("Addiere NumPy Arrays: Elementweise Summe!")
sum = arr1 + arr2
print(sum) # [6  8 10 12]
print("Elementweise Summe für Listen, ohne NumPy:")
sum = [x + y for x, y in zip(list1, list2)]
print(sum) # [6  8 10 12]
Die Verwendung von NumPy-Arrays in Anwendungen, die Daten desselben Datentyps verarbeiten, hat den Vorteil, dass viele häufig benötigte mathematische und statistische Funktionen schon vorhanden sind und benutzerfreundlich und effizient eingesetzt werden können.
Eine Konvertierung von und zu Python-Listen ist mittels Konvertierungs-Funktionen problemlos möglich:
# NumPy Array erstellen
arr = np.array([1, 2, 3, 4]) 
# NumPy Array in Liste konvertieren
list = arr.tolist() 

11-5 Matplotlib

Matplotlib ist eine Python-Bibliothek für Datenvisualisierung, die über das Paket pyplot das Erstellen von Diagrammen unterschiedlichster Art unterstützt: Linien-, Punkte-, Balkendiagramme, ein- und zweidimensonal, statisch oder interaktiv. Die wichtigsten Befehle zum Plotten sind plot für eindimensionale und surf für mehrdimensionale Diagramme. Der plot-Befehl erhält als Parameter die x- und y-Koordinaten der darzustellenden Daten, und optional einen String mit Formatierungsangaben. Weiterhin stehen viele Optionen zum Hinzufügen von Beschriftungen, Titeln, Legenden etc. zur Verfügung.

Python-Code: Matplotlib verwenden
import numpy as np  
import matplotlib.pyplot as plt
x = np.linspace(0,10,40)  # x-Werte
y1 = np.sin(x);y2 = np.cos(x);  # y-Werte
fig = plt.figure(figsize=[6, 3])  # Diagrammfenster mit festgelegter Größe
plt.plot(x, y1,'r*', label='sin');  # Plot der Sinus-Funktion
plt.plot(x, y2,'b+', label='cos');  # Plot der Cosinus-Funktion
plt.title('Sinus und Cosinus-Funktion');
plt.grid(True)
plt.legend(loc="upper center")
plt.xlabel('x');plt.ylabel('y');
Ausgabe: Datenvisualisierung mit Matplotlib Matplotlib

11-6 Pandas

Pandas ist eine Python-Bibliothek, die spezielle Datenstrukturen - Series und DataFrames - für den Zugriff auf Excel-ähnliche beschriftete Datentabellen anbietet, sowie viele Funktionen, mit deren Hilfe die Daten erstellt, bearbeitet und visualisiert werden können. In der Datenanalyse spielt Pandas eine zentrale Rolle, da damit große Excel- und csv-Dateien in den Arbeitsspeicher des Programms geladen werden, mit dem Ziel, die Daten anschließend zu analysieren und visualisieren. Pandas-Funktionen wie iloc(), loc(), resample() werden verwendet, um Zeilen / Spalten / Zellen auszuwählen und Daten zu gruppieren und aggregieren.


Python-Code: Pandas verwenden (1)
In diesem Beispiel werden mit Hilfe der Pandas-Funktion read_excel() Daten aus einer Excelmappe in ein DataFrame eingelesen und mittels to_csv() in eine csv-Datei geschrieben. Die Excel-Datei studenten.xslx können Sie hier herunterladen, danach einfach der Variablen file den geänderten Dateinamen inkl. Pfadangabe übergeben.
Datei studenten.xlsx herunterladen
import pandas as pd
# Daten aus studenten.xlsx einlesen, erste Spalte enthält den Index
file = 'https://www.elab2go.de/demo-py1/studenten.xlsx'
df = pd.read_excel(file, index_col=0, parse_dates=True) 
# Daten in die csv-Datei schreiben, mit angegebenem Trennzeichen
df.to_csv('studenten.csv', index=True, sep = ';')
# DataFrame df ausgeben
df
Ausgabe
Das DateFrame df wird einfach durch Angabe des Namens formatiert ausgegeben. Zeile 4: Die Angabe index_col = 0 im Funktionsaufruf bewirkt, dass die erste Spalte der Excelmappe (hier: die Spalte ID) als Index-Spalte festgelegt wird, d.h. sie wird die eindeutigen Zeilenbeschriftungen enthalten. Pandas: Daten aus Excel einlesen
Python-Code: Pandas verwenden (2)
In diesem Beispiel wird ein DataFrame mit Hilfe der Funktion pd.DataFrame aus einem Dictionary gebildet, das jedem Spalten-Namen eine Liste von Werten zuordnet, z.B. die Spalte Name enthält die Liste der Namen Muster, Test und Doe.
import pandas as pd
# Erzeuge ein Dictionary (Name-Wert-Paare)
studenten = { 
"Name": ["Muster", "Test", "Doe"], 
"Vorname": ["Max", "Anna", "John"], 
"Alter": [22, 24, 26],
"Note": [1.7, 2.1, 1.3]
} 
# Erzeuge DataFrame aus Dictionary 
df = pd.DataFrame(studenten) # DataFrame aus Dictionary 
print(df)
# Scatter-Plot Note vs. Alter
df.plot.scatter(x = 'Alter', y = 'Note', c='Red');
Ausgabe Pandas: Daten aus Dictionary und plotten

11-7 Scikit-Learn

Scikit-Learn ist eine Python-Bibliothek für Maschinelles Lernen und bietet Unterstützung für die üblichen Schritte des Überwachten und Unüberwachten Lernens: Datenvorbereitung, Trainingsphase und Modellevaluation, ebenso leistungsstarke Algorithmen für Klassifikations-, Regressions- und Clustering-Probleme. In dem folgenden Beispiel wird der vereinfachte Ablauf beim Trainieren eines Entscheidungsbaum-Modells für die Klassifikation von Ausfällen gezeigt: Einlesen der Daten mit Hilfe der Funktion read_csv, Extrahieren der Merkmale und der Zielvariablen, Aufteilen in Trainings- und Validierungsdaten mit train_test_split, Trainieren des Modells mittels fit-Funktion, Visualisierung mittels der Funktion plot_tree.


Python-Code: Scikit-Learn verwenden
Entscheidungsbaum-Modell trainieren
import pandas as pd
import matplotlib.pyplot as plt 
from sklearn import model_selection as ms
from sklearn import tree
df = pd.read_csv("messungen.csv", header=0, sep = ";", index_col=0)  
print('DataFrame mit Temperatur-Daten:\n', df);  
# Extrahiere Merkmale in ein Numpy-Array x  
x = df.iloc[:,0:2].to_numpy()  
# Extrahiere Zielvariable in ein Numpy-Array y   
y = df[['ausfall']]  
y = y.values   
# 90% Trainingsdaten und 10% Testdaten  
X_train, X_test, y_train, y_test =  ms.train_test_split(x, y, test_size=0.1, random_state=1)   
model = tree.DecisionTreeClassifier(criterion='entropy', splitter='best')  
# Erzeuge Entscheidungsbaum  
model.fit(X_train, y_train)
# Visualisiere Entscheidungsbaum 
fig, ax = plt.subplots(figsize=(5, 5)) 
tree.plot_tree(model, filled=True, feature_names=df.columns[0:2], class_names=['ja','nein'])
plt.show()
Ausgabe
Scikit-Learn: Datensatz    Scikit-Learn: Entscheidungsbaum

12 Python-Pakete für Machine Learning

Für Machine Learning und Deep Learning im engeren Sinn, also die Verwendung leistungsfähiger Künstlicher Neuronaler Netzwerke, bietet Python gleich mehrere Programmbibliotheken, darunter PyTorch, JAX, Tensorflow und Keras. Diese Pakete bieten ähnliche Funktionalität für die Erstellung und Verwendung von Deep Learning-Modellen, sind jedoch nicht als gleichwertig zu betrachten. Keras insbesondere ist ein Paket mit Wrapper-Funktionalität, das mit jedem der drei anderen Pakete als Backend verwendet werden kann. PyTorch, JAX und Tensorflow unterscheiden sich in der internen Umsetzung der Verfahren und auch in der Verwendung der API-Funktionen.


  Übersicht: Python Pakete für Machine Learning

12-1 Keras

Keras ist ein Python-Paket, das als benutzerfreundliche Programmierschnittstelle für verschiedene Machine Learning Frameworks wie Tensorflow, PyTorch und JAX verwendet wird.

Keras bietet zum Erstellen eines neuronalen Netzwerks zwei Klassen: Sequential und Functional, die beide die Erstellung mehrschichtiger Netzwerke unterstützen. Die Sequential-API ermöglicht das sequentielle Zusammenzufügen von Schichten (Layer), während mit Hilfe der Functional-API komplexere Anordnungen von Schichten erstellt werden können.

Die Schichten eines Künstlichen Neuronalen Netzwerks sind in Keras durch die Klassen der Layer-API realisiert: Conv2D, MaxPooling2D, Flatten, Dense, LSTM etc. Jede Layer-Klasse hat eine Gewichtsmatrix, eine Größenangabe für die Anzahl verwendeter Neuronen (units), eine Formatbeschreibung der Eingabedaten (input_shape), eine Aktivierungsfunktion (activation), und eine Reihe weiterer Parameter, die die Gestaltung der Schicht steuern.

Die üblichen Schritte beim Erstellen eines Neuronalen Netzwerks (Modell erstellen, Modell trainieren, Modell validieren und verwenden) werden in Keras mit Hilfe der Funktionen compile(), fit() und predict() durchgeführt.

12-2 Tensorflow

Google's Tensorflow ist ein Framework für Machine Learning, das insbesondere für Anwendungen in der Bild- und Spracherkennung genutzt wird. Tensorflow bietet Programmierschnittstellen für verschiedene Programmiersprachen an, insbesondere Python, Java und C++, davon ist die meistgenutzte und stabilste Schnittstelle die Python API. Die Dokumentation der Tensorflow-API ist umfangreich und die zur Verfügung gestellten Beispiele können durch Ausführung der verlinkten Colab-Notebooks praktisch nachvollzogen werden.

Tensorflow wird zunächst für Aufgaben in der Bild- und Videobearbeitung eingesetzt, sowohl für Aufgaben der Bilderkennung (ist ein Objekt da?) als auch der Bild-Klassifikation (um welches Objekt handelt es sich?). Das Trainieren eines Modells in der Bildklassifikation ist sehr aufwendig - hier kann man mit Tensorflow auf vortrainierte Modelle zurückgreifen und einfach diese für die Klassifikation verwenden.

Was genau ist ein Tensor? Ein Tensor ist im Sprachgebrauch des Machine Learning eine mehrdimensionale konstante Datenstruktur mit einem eigenen Satz an Operationen, die die mathematische Einheit eines künstlichen Neuronalen Netzwerks darstellt. Im Unterschied zu den bekannten mehrdimensionalen Datenstrukturen wie Listen oder Matrizen kann ein Tensor nicht nur mehrere Dimensionen, sondern auch mehrere Achsen haben.
https://www.tensorflow.org/guide/tensor
import tensorflow as tf
import numpy as np
rank_3_tensor = tf.constant([
  [[0, 1, 2, 3, 4],
   [5, 6, 7, 8, 9]],
  [[10, 11, 12, 13, 14],
   [15, 16, 17, 18, 19]],
  [[20, 21, 22, 23, 24],
   [25, 26, 27, 28, 29]],])

print(rank_3_tensor)

12-3 Bilderkennung mit Keras und Tensorflow

Das folgende Beispiel zeigt, wie ein Künstliches Neuronales Netzwerk für die Ziffernerkennung mit Hilfe von Keras trainiert und für die Klassifikation verwendet wird. Das Ziel ist, ein Modell zu erstellen und zu trainieren, das handgeschriebene Ziffern (grau-weiß-Bilder im Format 28x28 Pixel, die die Ziffern 0,1,2,...,9 darstellen) korrekt klassifizieren kann.

MNIST Ziffern-Datensatz
Fünf Beispiel-Bilder aus dem MNIST-Datensatz


Unser Beispiel für Ziffernerkennung ist an das Simple MNIST convnet aus der Sammlung der Keras-Codebeispiele angelehnt. Der vollständige Quellcode mit zusätzlichen Erläuterungen ist als Google Colab Notebook online verfügbar.

  Notebook "Python Tutorial - Keras und Tensorflow" in neuem Fenster öffnen!


Schritt 1: Daten einlesen und vorbereiten

Als Trainings- und Validierungsdatensatz werden 60.000 Ziffern-Bilder aus dem MNIST-Ziffern-Datensatz verwendet. Der MNIST-Ziffern Datensatz kann direkt über Keras geladen werden.
  Die Datenvorbereitung bedeutet, dass die Bild-Daten in eine vorgegebene numerische Form umgewandelt, normalisiert und codiert werden müssen.
  Verwendete Funktionen: load_data(), reshape(), to_categorical()

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.utils import to_categorical, plot_model
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Dense, Flatten
print("1. Lade MNIST-Datensatz")
(trainX, trainY), (testX, testY) = mnist.load_data()
# Ausgabe der Dimensionen des Datensatzes
print('Train: X=%s, Y=%s' % (trainX.shape, trainY.shape))
print('Test: X=%s, Y=%s' % (testX.shape, testY.shape))
print("2. Datenvorbereitung")
trainX = trainX.reshape((trainX.shape[0], 28, 28, 1))
testX = testX.reshape((testX.shape[0], 28, 28, 1))
# Daten werden in den Bereich [0, 1] normalisiert
trainX = trainX.astype("float32") / 255.0
testX = testX.astype("float32") / 255.0
# Zielvariable wird numerisch codiert
trainY = to_categorical(trainY)
testY = to_categorical(testY)
print('Train: X=%s, Y=%s' % (trainX.shape, trainY.shape))
print('Test: X=%s, Y=%s' % (testX.shape, testY.shape))
Ausgabe Datenvorbereitung mit Keras

Schritt 2: Modell definieren und trainieren

In diesem Schritt wird ein Deep Learning-Modell erstellt, für die Trainingsphase konfiguriert und anschließend anhand der zuvor festgelegten Trainingsdaten trainiert.
  Das Modell wird durch Hinzufügen passender Schichten erstellt. Für jede Schicht kann eine Aktivierungsfunktion angegeben werden.
 Verwendete Klassen: Sequential, Conv2D, MaxPooling2D, Flatten, Dense
 Verwendete Methoden: compile(), summary(), fit(), save()

# Definiere das Modell
print("3. Definiere das Modell")
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy', metrics=['accuracy'])
model.summary()
# Trainiere das Modell
print("4. Trainiere das Modell\n")
model.fit(trainX, trainY, epochs=8, batch_size=64, verbose=2)
# Speichere das Modell
model.save('digits_model.keras')
Ausgabe
Keras: Modell erstellen    Keras: Modell trainieren

Schritt 3: Modell evaluieren

In diesem Schritt wird die Güte des Modells bestimmt, dabei werden die Indikatoren loss und accuracy (Vertrauenswahrscheinlichkeit) verwendet.
  Mit Hilfe des Parameters loss wurde bei Erstellung konfiguriert, welche Performance-Metrik während des Trainings minimiert werden soll.
 Die Vertrauenswahrscheinlichkeit ist die Wahrscheinlichkeit, dass für eine Beobachtung eine richtige Vorhersage getroffen wird.
  Verwendete Funktionen: evaluate()

score = model.evaluate(testX, testY, verbose=0)
print("Test loss:", score[0]) # Ausgabe: Test loss: 0.03
print("Test accuracy:", score[1]) # Ausgabe: Test accuracy: 0.99

Schritt 4: Modell für die Klassifikation neuer Bilder verwenden

In diesem Schritt wird das zuvor erstellte Modell verwendet, um neue Bilder korrekt zu klassifizieren.

4-1 Bild laden
Zunächst muss das zu klassifizierende Bild geladen und numerisch dargestellt werden. Konkret wird hier ein Bild, das die Ziffer 5 darstellt, aus einer URL geladen und in die von dem Modell benötigte numerische Darstellung umgewandelt.
  Die selbstdefinierte Funktion prepare_image() hat die Aufgabe, ein als URL übergebenes Bild zu laden und numerisch codiert als NumPy-Array darzustellen.
  Verwendete Funktionen: load_img(), img_to_array()

from keras.preprocessing import image
from keras.utils import get_file

def prepare_image(img_url):  
  '''
  Funktion lädt ein Bild aus einer URL
  und stellt es numerisch codiert als NumPy-Array dar
  '''
  img = None
  try: 
    file = get_file('fname',img_url) # Lade die Datei aus der URL in eine lokale Datei
    # Lade Bild im PIL-Format, 28x28 Pixel
    img = image.load_img(file, color_mode = 'grayscale', target_size=(28, 28))
    # Wandle es in ein Array um
    img = image.img_to_array(img)
    img = img.reshape(1, 28, 28, 1)
    img = img.astype('float32') / 255.0
  except Exception as error:
    print("Error: %s" % error)
  return img
# Test-Bild laden und codieren: digit-5 kann ersetzt werden durch digit-7 etc.
img_url = 'https://elab2go.de/demo-py1/images/digit-5.png'
img = prepare_image(img_url)
print(img) # 

4-2 Modell laden und Vorhersage durchführen
 Das Modell wird aus der zuvor gespeicherten *.keras Datei geladen.
  Die Klassifikation mittels der predict-Funktion liefert als Ergebnis ein NumPy-Array aus 9 Werten zurück, wobei eine 1 an der i-Stelle i bedeutet, dass das Bild als Zahl i klassifiziert wurde.
  Verwendete Funktionen: load_model(), predict()

from keras.models import load_model
# Modell aus Datei laden
model = load_model('digits_model.keras')
# Vorhersage / Klassifikation erstellen
arr = model.predict(img)
# Das Ergebnis ist ein Array z.B. [0,0,0,0,1,0,0,0,0]
print("Array als float:\n", arr) 
# Konvertiere digit_arr in ein ganzzahliges Array
arr = (np.rint(arr[0])).astype(int)
print("Array als int:\n", arr)
print("Das Bild stellt folgende Zahl dar:")
print(np.where(arr == 1)[0])
Ausgabe für das Bild digit-5.png Ziffern-Klassifikation mit Keras

13 Python-Pakete für Kryptographie

Python bietet unterschiedliche Pakete für kryptographische Funktionen, einerseits hashlib, hmac und secrets als Teil der Python Standardbibliothek, andererseits diverse Pakete von Drittanbietern. Die Pakete hashlib und hmac bieten Funktionen für Hashing und die Erzeugung von Message Authentication Codes. Das Paket secrets wird für die Erzeugung kryptographisch sicherer Zufallszahlen eingesetzt. Das Python-Paket PyCrypto bzw. die neuere Version PyCryptoDome implementiert eine Reihe kryptografischer Verfahren, die in eigenen Python-Programmen für Verschlüsselung und digitale Signaturen eingesetzt werden können:

Beispiel
Im folgenden Beispiel wird der Klartext "Hallo zusammen!" mit Hilfe der AES-Verschlüsselung im EAX-Betriebsmodus verschlüsselt. In diesem Modus wird die Nachricht gleich auch mit einem MAC-Code authentifiziert. Wir erzeugen beim Verschlüsseln einen Einmal-Code nonce und ein Message Authentication Tag mac_tag. Nonce wird später für die Entschlüsselung und mac_tag für die Überprüfung der Authentizität bei der Entschlüsselung benötigt. Der Schlüssel key ist hier 16 Byte lang, deswegen wählen wir 16 Buchstaben. Wird die Verschlüsselung des Klartextes mehrfach ausgeführt, ist der Chiffretext jedesmal ein anderer!


Python-Code: AES-Verschlüsselung
  Verwendete Klassen: AES
  Verwendete Methoden: encrypt_and_digest()
from Crypto.Cipher import AES
key = b'Sixteen byte key'
cipher = AES.new(key, AES.MODE_EAX)
nonce = cipher.nonce
klartext = "Hallo zusammen!"
chiffretext, mac_tag = cipher.encrypt_and_digest(klartext.encode())
print("Verschlüsselte Nachricht: ", chiffretext, "\nSignatur: ", mac_tag)

Python-Code: AES-Entschlüsselung
  Verwendete Klassen: AES
  Verwendete Methoden: decrypt(), verify()
from Crypto.Cipher import AES
key= b'Sixteen byte key'
cipher = AES.new(key, AES.MODE_EAX, nonce=nonce)
klartext = cipher.decrypt(codetext)
try:
  cipher.verify(mac_tag)
  print("Die Nachricht ist authentisch!:", klartext)
except ValueError:
  print("Schlüssel falsch oder Nachricht verfälscht!")

14 Python vs 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:

Wie jede Programmiersprache hat Python Eigenschaften, die sie für bestimmte Einsatzgebiete besonders geeignet machen, und ist andererseits nicht für alles einsetzbar. Für Echtzeitanwendungen sind die Programmiersprachen C oder C++ das Mittel der Wahl. Für große Anwendungen mit komplexer Softwarearchitektur, wo bei Entwurf und Entwicklung die komplette Palette der objektorientierten Programmierung eingesetzt werden muss, 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.

Autoren, Tools und Quellen

Autor:
 Prof. Dr. Eva Maria Kiss
Mit Beiträgen von:
 M. Sc. Anke Welz


Tools:

elab2go-Links

Quellen und weiterführende Links

  • [1] Offizielle Python Dokumentation bei python.org: docs.python.org/3/tutorial/
    sehr umfangreich, Nachschlagewerk, hier findet man Dokumentationen für verschiedene Python-Versionen
  • [2] Python Tutorial bei Google Developers: developers.google.com/edu/python/introduction
    umfangreich, für Fortgeschrittene, verweist auf die offizielle Dokumentation
  • [3] Python Tutorial bei W3Schools: w3schools.com/python/ – für Einsteiger geeignet, interaktive Ausführung im Browser
  • [4] Python Cheatsheet: evamariakiss.de/tutorial/python/ – zum Nachschlagen der wichtigsten Python-Befehle, mit Selbsttest / Quiz
  • [5] NumPy: numpy.org/ – Mehrdimensionale Arrays, Mathematische Funktionen, Zufallszahlen
  • [6] Matplotlib: matplotlib.org/ – Datenvisualisierung, Plotten
  • [7] Pandas: pandas.pydata.org/ – Datenverwaltung, Datenvorbereitung, DataFrames, Series
  • [8] Scikit-Learn: scikit-learn.org – Algorithmen für Maschinelles Lernen
  • [9] Keras: keras.io – Künstliche Neuronale Netzwerke, Deep Learning