Python

schnell und intensiv Programmieren lernen

Berry Boessenkool frei verwenden, zitieren 2024-10-30 21:12

Python MOOC TOC 1/ 145

1. Intro 1.1 Willkommen
2. Objekte 1.2 Syntax
3. Schleifen 1.3 Datentypen
4. Programmieren 1.4 Funktionen schreiben
1.5 Module importieren
1.6 Zeichenketten

Python MOOC - 1.1 Willkommen TOC 2/ 145

Willkommen

▶ Berry
▶ 2008-2017 Geoökologie @ Uni Potsdam
▶ ”versehentlich” ein -Fan geworden
▶ Pakete , Community , Training & Beratung
▶ seit 2019 in Teilzeit Dozent am HPI (Lehrstuhl Bert Arnrich)
▶ seit 2021 auch -Unterricht

Python MOOC - 1.1 Willkommen TOC 3/ 145

Kursphilosophie

▶ Python Grundlagen in zügigem Tempo

▶ Rechne mit 5-10 Stunden Aufwand pro Woche!
▶ Trotz KI-Assistenten: selbst programmieren (lernen) können
▶ Ziel: effizient und reproduzierbar arbeiten

▶ Python Eigenschaften (Quelle):

▶ interpretierte Sprache (keine Kompilierung)
▶ dynamische Typisierung (Datentypen werden zur Laufzeit überprüft)
▶ objektorientiert (Daten mit Methoden)
▶ high-level (von Menschen lesbar)

▶ Eingesetzt in Data Science, Machine Learning, Webentwicklung,

Spielentwicklung, Robotik, autonome Fahrzeuge, Entwicklung
graphischer Nutzeroberflächen, Finanzwesen, ...

Python MOOC - 1.1 Willkommen TOC 4/ 145

Kursablauf

▶ 14 Lektionen
▶ Video
▶ PDF (pro Woche KursPDF mit allen Folien) mit
# Python Code auf grauem Hintergrund
▶ Multiple Choice Quiz (Selbsttest)
▶ Automatisch bewertete Programmieraufgaben
▶ Zeit und Dauer der Bearbeitung frei wählbar
▶ Kursinhalte in der Kursbeschreibung
▶ pro Kurswoche (für einen Leistungsnachweis)
▶ Multiple Choice Quiz (Hausaufgabe)
▶ Nach Beginn 60 Minuten Zeit
▶ Fragen
▶ Kursforum [Diskussionen] + Kommentaranfragen
▶ Themenbezogene Fragen unter den Videos stellen
▶ Beitragstitel zum leichten Suchen im Format "1.3 A5" beginnen
▶ Gegenseitig beantworten und intensiver lernen!

Python MOOC - 1.1 Willkommen TOC 5/ 145

Ressourcen

▶ Download & Installation, Hinweise für Windows

▶ offizielle Dokumentation und Sprachreferenz
▶ Drucken: RefCard, zB. Laurent Pointal, Berry (nah am Kurs), Suche
▶ [Link]: Programmierwettbewerbe mit Suchtpotenzial

▶ Ausführlichere (langsamere) Kurse:

▶ openHPI deutscher Python Junior Kurs
▶ bodenseo deutsche Webseite + Buch
▶ Computer Science Circles interaktiver englischer Kurs
▶ [Link] offizielles englisches Tutorial

Python MOOC - 1.1 Willkommen TOC 6/ 145

Integrated development environment (IDE)

▶ Programmieraufgaben sind im Browser lösbar

▶ Im echten Leben lokal arbeiten - in einer Entwicklungsumgebung
▶ Für Python gibt es Hunderte IDEs (Top 9, RStudio)
▶ Ich empfehle VS Code (ggf. Telemetry ausschalten)
▶ für viele Sprachen, z.B. Python, R, Julia, JavaScript, C++, SQL
▶ kann Script ausführen oder einzelne Zeilen (Demo)
▶ Wer’s braucht: Jupyter notebooks (Julia, Python, R), zB. google

Python MOOC - 1.1 Willkommen TOC 7/ 145

Programmieraufgaben

Zu jeder Lektion gibt es interaktive Code-aufgaben im Browser.

Der Zugang erfolgt via openHPI (nicht direkt per URL).

Python MOOC - 1.1 Willkommen TOC 8/ 145

Programmieraufgaben in CodeOcean

1. Runterladen (lokal bearbeiten)

2. Alle Skripte dieser Lektion (heißt hier ”Aufgabe”) zurücksetzen
3. Skript ausführen lassen
4. Komplette Aufgabe bewerten lassen
5. Kommentaranfrage stellen (für individuelle Hilfe)
6. (unten): ein einzelnes Skript zurücksetzen

Python MOOC - 1.1 Willkommen TOC 9/ 145

Programmieraufgaben Hinweise
Sollte beim Bewerten rechts unten mal ERROR: test** statt FAIL: stehen,
bitte den Fehler verzeihen und die Nachricht im Forum melden.
Es ist nicht nötig, 100% zu erreichen um mit anderen Aufgaben im Kurs
weiterzumachen.
Ich teile keine gebündelten Musterlösungen:
▶ es schränkt deine Kreativität und Diversität ein (es gibt meistens mehrere
Lösungswege)
▶ es geht viel Lerneffekt verloren, wenn man dann doch ”kurz reinschaut”
▶ du musst unbedingt lernen, selbst Lösungen zu finden
▶ zu einzelnen Aufgaben darfst du im Forum nach besseren Ansätzen fragen
(didaktisch wertvoll). Schaue auch gerne in die Kommentaranfragen
anderer Teilnehmer rein.
▶ das Testskript schaut bereits, ob deine Lösung generalisiert anwendbar ist
▶ Good Coding ist eine Stilfrage, wo ich nicht allzuviel vorschreiben möchte

Python MOOC - 1.1 Willkommen TOC 10/ 145

Zusammenfassung für 1.1 Willkommen

Vorstellung, Python, Programmieraufgaben:

▶ Programmieren ist eine mächtige Kompetenz
▶ Python ist toll
▶ Fragen im Forum stellen und beantworten
▶ RefCard drucken
▶ Wenn du lokal arbeiten willst: Python und VScode installieren
▶ Programmieraufgaben mit automatischer Bewertung

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 1.1 Willkommen TOC 11/ 145

1. Intro 1.1 Willkommen
2. Objekte 1.2 Syntax
3. Schleifen 1.3 Datentypen
4. Programmieren 1.4 Funktionen schreiben
1.5 Module importieren
1.6 Zeichenketten

Python MOOC - 1.2 Syntax TOC 12/ 145

Operatoren, Kommentare
5 + 8 # Kommentare (nach einer Raute) werden ignoriert
## 13
6/7 # Leerzeichen sind irrelevant (hier)
## 0.8571428571428571
12 * 3.4 # Dezimalzahlen mit einem Punkt angeben
## 40.8
3 ** 2 # Exponenten (nicht 3^2!)
## 9
19 // 3 # ganzzahlige Division
## 6
19 % 3 # Modulo (Rest nach ganzahliger Division)
## 1
'''
Dies ist ein Kommentar
über mehrere Zeilen.
-> Gut zum Dokumentieren von Code :)
'''
Python MOOC - 1.2 Syntax TOC 13/ 145
Objekte, Ausgaben auf der Konsole (shell / terminal)
Objekt erstellen mit = Zeichen:
x = "Hallo, python Welt!"
x
## 'Hallo, python Welt!'
Zeichenketten sind erstellbar mit " und ’ .
In den meisten Umständen (z.B. VS Code, CodeOcean), braucht es einen
expliziten Aufruf, um etwas in der Konsole anzuzeigen:
print(x)
## Hallo, python Welt!
print braucht man nicht in jupyter notebooks, bei zeilenweiser
Ausführung und in diesen Folien (erstellt mit Rnw = + LATEX).

Wenn du in VScode Befehle zeilenweise ausführst ( >>> in console),

kannst du mit quit() wieder in den normalen Modus wechseln.

Python MOOC - 1.2 Syntax TOC 14/ 145

print

print("Ich schreibe: ", x)

## Ich schreibe: Hallo, python Welt!
print konkateniert verschiedene Eingaben, getrennt durch sep
(default " " ) und abgeschlossen mit end (default "\n" )
a = 5
print("a ist:", a, "gut", sep="0", end="\n\n\n")
print("a ist immer noch:", a)
## a ist:050gut
##
## a ist immer noch: 5
print("Berlin", end = "#")
print("Potsdam")
## Berlin#Potsdam

Python MOOC - 1.2 Syntax TOC 15/ 145

Häufige Fehler bei Objektnamen
a = 42
Groß-/Kleinschreibung beachten:
A + 88
## NameError: name ’A’ is not defined
Objektnamen dürfen nicht mit Zahlen beginnen:
12b = 67 / 5
## SyntaxError: invalid decimal literal
Schlüsselwörter dürfen nicht als Objektnamen verwendet werden:
class = 4
## SyntaxError: invalid syntax
Ausführliche Liste häufiger Fehler, Liste der reservierten Keywords
SyntaxError: oft Klammern oder Doppelpunkte vergessen (in Schleifen)

Objektnamen sollten kurz und informativ sein,

z.B. anzahl teilnehmer oder video dauer

Python MOOC - 1.2 Syntax TOC 16/ 145

Objektmethoden I

eine_liste = [42, 77, -5, 6]

eine_liste
## [42, 77, -5, 6]
eine_liste.append(111) # Methode für Listenobjekte
Das Objekt wird verändert, ohne es neu zuzuweisen
(wenn es veränderbar ist, siehe Lektion 2.1 Objekttypen).
eine_liste
## [42, 77, -5, 6, 111]

Python MOOC - 1.2 Syntax TOC 17/ 145

Objektmethoden II

Wenn eine Methode ein Objekt zurückgibt, können Methoden verknüpft

werden (chaining):
satz = "Eine normale Zeichenkette"
[Link]("e") # zählt nur kleine e
## 6
[Link]() # macht alles klein
## 'eine normale zeichenkette'
[Link]().count("e") # zählt alle e
## 7

Python MOOC - 1.2 Syntax TOC 18/ 145

interaktive Nutzereingabe

nutzer_eingabe = input()
print("Die Eingabe war:", nutzer_eingabe)
nutzer_eingabe = input("Bitte etwas eingeben: ")
Die Ausgabe von input ist immer eine Zeichenkette (string), auch
wenn eine Zahl eingegeben wird.

Python MOOC - 1.2 Syntax TOC 19/ 145

Funktionen aus Modulen

Grundlegende Befehle wie print , + , input , etc sind immer

verfügbar. Funktionen wie sqrt sind in einem eigenen Paket (Modul).
Diese müssen zuerst geladen werden:
import math
[Link](700)
## 26.457513110645905

Weitere Methoden in Lektion 1.5 Module importieren

Python MOOC - 1.2 Syntax TOC 20/ 145

Zeilen einer Textdatei lesen

fname = "[Link]"
with open(fname) as f:
inhalt = [Link]() # .splitlines()
print(inhalt)
## Dies ist ein kleines Beispiel einer Textdatei
## um das Einlesen von Zeilen in Python zu demonstrieren.
## Für echte Daten das Paket `pandas` verwenden!
open("[Link]") öffnet die Datei im Lesemodus
with garantiert, dass die Datei am Ende geschlossen wird (besonders
im Falle eines Fehlers)
Die Zeile nach with muss eingerückt sein
[Link]() gibt eine Liste mit einer Textzeile pro
Listenelement aus

Python MOOC - 1.2 Syntax TOC 21/ 145

kürzere Zuweisungen

a = 17
a = a + 8
a
## 25
a = 17
a += 8
a
## 25
In der DataScience als schlecht lesbar angesehen und nicht sehr
empfohlen, wird aber besonders in Schleifen durchaus verwendet.
a *= a+2 # a = a*(a+2)

Python MOOC - 1.2 Syntax TOC 22/ 145

Zusammenfassung für 1.2 Syntax

Syntax, Objekte, Operatoren, Funktionen:

▶ + , - , * , / , ** , // , %
▶ obj = "string" # Kommentar ;
"""mehrzeiliger Kommentar"""
▶ print("Zeichen", 42, obj, sep=" ", end="\n")
▶ [Link]() ; [Link]().count("p")
▶ nutzer_eingabe = input()
▶ import modul ; [Link](x)
▶ with open("[Link]") as f: inhalt = [Link]()

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 1.2 Syntax TOC 23/ 145

1. Intro 1.1 Willkommen
2. Objekte 1.2 Syntax
3. Schleifen 1.3 Datentypen
4. Programmieren 1.4 Funktionen schreiben
1.5 Module importieren
1.6 Zeichenketten

Python MOOC - 1.3 Datentypen TOC 24/ 145

Datentypen

Wir haben schon drei Sorten von Daten gesehen: ganze Zahlen,
Kommazahlen und Zeichenketten.
type(5)
## <class 'int'>
type(5.67)
## <class 'float'>
type("Zeichen")
## <class 'str'>
print(7 > 4, 7 < 4)
## True False
type(7 > 4)
## <class 'bool'>
type(2+3j) # Komplexer Teil mit j statt mit i
## <class 'complex'>

Python MOOC - 1.3 Datentypen TOC 25/ 145

Datentyp prüfen

isinstance(7.5, int) # Klassenzugehörigkeit prüfen

## False
isinstance("Hello", (float, int, str) ) # einer von den 3
## True
obj = "Zeichenkette"
print("Typ ist: ", type(obj) )
## Typ ist: <class 'str'>

Python MOOC - 1.3 Datentypen TOC 26/ 145

Datentyp ändern (konvertieren)

int("48")
## 48
float("48")
## 48.0
int("drei") # Fehler falls nicht konvertierbar
## ValueError: invalid literal for int() with base 10:
’drei’
type(float("25"))
## <class 'float'>

Python MOOC - 1.3 Datentypen TOC 27/ 145

Typenkonvertierung Demo

# Coding demo:
f = float(input('Temperatur in °Fahrenheit eingeben: '))
c = (f-32) / 1.8
print("Temperatur in °Celcius:", round(c, 1))

Python MOOC - 1.3 Datentypen TOC 28/ 145

Zusammenfassung für 1.3 Datentypen

Datentypen ermitteln:
▶ type(objekt)
▶ int(etwas das konvertiert werden kann)
▶ isinstance(objekt, int)
▶ isinstance(objekt, (float, int, str) )

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 1.3 Datentypen TOC 29/ 145

1. Intro 1.1 Willkommen
2. Objekte 1.2 Syntax
3. Schleifen 1.3 Datentypen
4. Programmieren 1.4 Funktionen schreiben
1.5 Module importieren
1.6 Zeichenketten

Python MOOC - 1.4 Funktionen schreiben TOC 30/ 145

Funktionssyntax I

def willkommen(name, zeit="morgen"):

msg = "Hallo, " + name + ". Guten " + zeit + "!"
return msg
willkommen(name='Bob', zeit='Abend')
## 'Hallo, Bob. Guten Abend!'
willkommen(name='Berry') # mit dem Standardfall (morgen)
## 'Hallo, Berry. Guten morgen!'
▶ Doppelpunkt : notwendig, danach einrücken
▶ mit Leerzeichen oder Tabstop, Hauptsache einheitlich
▶ Ohne explizites return gibt eine Funktion None zurück
▶ return beendet den Funktionsaufruf
▶ name & zeit sind Parameter, ”Berry” & ”Abend” sind Argumente
▶ Syntax: parameter=argument

Python MOOC - 1.4 Funktionen schreiben TOC 31/ 145

Funktionssyntax II
▶ Parameternamen können beim Aufruf weggelassen werden, sofern
die Argumente in der richtigen Reihenfolge gegeben werden:
willkommen("Lydia", "Mittag")
## 'Hallo, Lydia. Guten Mittag!'
▶ print() zeigt eine Ausgabe in der Konsole an.
▶ return beschreibt den Funktionsrückgabewert,
▶ der danach zugewiesen werden kann
▶ und mit dem weitergearbeitet werden kann.
▶ In der Realität eigentlich immer return verwenden

▶ Das Wort ”ausgeben” wird für ”zurückgeben” und ”anzeigen”

verwendet. In den Programmieraufgeben ist meist return oder
print vorgegeben.

▶ IndentationError: Zu wenig oder zu viel Einrückung

Python MOOC - 1.4 Funktionen schreiben TOC 32/ 145
Beispiel einer Funktion
import math
def kugel_volumen_berechnen(radius, nachkommastellen=3):
volumen = (4/3) * [Link] * radius**3
gerundet = round(volumen, nachkommastellen)
return gerundet
kugel_volumen_berechnen(2)
## 33.51
kugel_volumen_berechnen(2, 5)
## 33.51032
Was ist hier gut?
▶ Funktionsname ist ein Verb
▶ Parameternamen erklären sich selbst
▶ gute Objektnamen innerhalb der Funktion
▶ math außerhalb der Funktion importiert

Python MOOC - 1.4 Funktionen schreiben TOC 33/ 145

Scoping (Gültigkeitsbereich) - welche Objekte werden gefunden I
Lokale Objekte in einer Funktion haben Vorrang:
import math
def tische_zaehlen(n):
tische = n/6
aufgerundet = [Link](tische)
return aufgerundet
anzahl_gaeste = 78
tische_zaehlen(anzahl_gaeste)
## 13
tische = 4000
tische_zaehlen(22) # Funktion verwendet internes Objekt
## 4
aufgerundet
## NameError: name ’aufgerundet’ is not defined
Lokale objekte (innerhalb einer Funktion) sind temporär und nach der
Ausführung der Funktion nicht global verfügbar
Python MOOC - 1.4 Funktionen schreiben TOC 34/ 145
Scoping (Gültigkeitsbereich) - welche Objekte werden gefunden II

Globale Objekte sind in einer Funktion verfügbar:

def anzahl_stuehle(n):
return anzahl_gaeste
anzahl_stuehle(17)
## 78
Mit globalen Objekten innerhalb einer Funktion nur arbeiten, wenn man
weiß, was man tut!

Python MOOC - 1.4 Funktionen schreiben TOC 35/ 145

Zusammenfassung für 1.4 Funktionen schreiben

wiederverwendbare Codeblöcke:
▶ Funktionssyntax:
def funktionsname(parameter, mit_default="argument"):
ausgabe = parameter + 5
return ausgabe
parameter + 8 # code nach return nie ausgeführt
▶ Einrückung einheitlich
▶ print vs return beachten
▶ lokale Objekte existieren nur innerhalb der Funktion
▶ globale Objekte nicht in einer Funktion verwenden

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 1.4 Funktionen schreiben TOC 36/ 145

1. Intro 1.1 Willkommen
2. Objekte 1.2 Syntax
3. Schleifen 1.3 Datentypen
4. Programmieren 1.4 Funktionen schreiben
1.5 Module importieren
1.6 Zeichenketten

Python MOOC - 1.5 Module importieren TOC 37/ 145

Eingebaute Pakete (Module)
Python kommt mit einigen Modulen vorinstalliert (Standardbibliothek).
Diese müssen nicht installiert werden (Liste).
Zur verwendung in einem Skript müssen sie aber geladen werden.
import math
radius = float(input('Bitte Radius eingeben: '))
print("Der Umfang ist ", 2 * [Link] * radius)

Gute Praxis beachten:

from math import * # NICHT BENUTZEN!
from math import sqrt, pi # schwer nachvollziehbar
import math # sauber, lesbar
[Link] # -> Königsweg
import math as m # etwas kürzer
[Link] # pandas -> pd
Python MOOC - 1.5 Module importieren TOC 38/ 145
Externe Module
Populäre Pakete
▶ Data science: numpy , pandas
▶ Machine learning: tensorflow , pytorch
▶ Statistical analysis: scipy
▶ Web application: django
Quelle ▶ Plotting: matplotlib , seaborn
Module von [Link] (PYthonPackageIndex) installieren mit pip (bei
Python inklusive).
In Konsole / Terminal / Shell / bash / cmd:
pip install numpy # pip3 unter MacOS
pip list
Auf dem Macbook mache ich das mit R:
[Link]("reticulate")
reticulate::install_miniconda()
reticulate::py_install("numpy")

ImportError: Name falsch geschrieben?

Python MOOC - 1.5 Module importieren TOC 39/ 145
Beispiele für Paketnutzungen

Zufallszahlen:
import random
[Link]() # float von 0 (inkl) bis 1 (exklusive)
[Link](1, 6) # int von 1 (inkl) bis 6 (inkl!!!)

Zählung:
import collections
f = ['rot', 'blau', 'blau', 'gelb', 'blau', 'rot', 'lila']
[Link](f).most_common(3)
## [('blau', 3), ('rot', 2), ('gelb', 1)]

Mehrere Module können in einer Zeile importiert werden:

import collections, statistics, random

Python MOOC - 1.5 Module importieren TOC 40/ 145

Einlesen (Ausführen) von .py Dateien

Arbeitsverzeichnis (Pfad, Ordner), current working directory:

import os
[Link]().replace([Link], '/')
## 'C:/Dropbox/pymooc/folien'
Siehe auch das Modul pathlib

Dort liegt [Link] mit anzahl = 25 .

from meinskript import anzahl
print(anzahl+2)
## 27
Beachte: kein echter Dateiname (mit .py-Endung)!
import meinskript
[Link]
## 25

Python MOOC - 1.5 Module importieren TOC 41/ 145

Objekte in .py-Dateien

import meinskript
print("\n".join(dir(meinskript))) # Objekte im Modul
## __builtins__
## __cached__
## __doc__
## __file__
## __loader__
## __name__
## __package__
## __spec__
## anzahl
## job
## random
## simuliere_job

Python MOOC - 1.5 Module importieren TOC 42/ 145

Funktionen in .py-Dateien

type(meinskript.simuliere_job)
## <class 'function'>
meinskript.simuliere_job()
## 'coder'
meinskript.simuliere_job()
## 'arzt'
import inspect
print([Link](meinskript.simuliere_job))
## def simuliere_job():
## jobs = ["lehrer","handwerker","arzt","coder"]
## return [Link](jobs)
Wenn Argumente vorhanden sind:
[Link](meinskript.simuliere_job)
## FullArgSpec(args=[], ... defaults=None ...

Python MOOC - 1.5 Module importieren TOC 43/ 145

Zusammenfassung für 1.5 Module importieren

Module und Skripte importieren:

▶ import paket as pak ; [Link]()
▶ from paket import fun ; fun()
▶ pip install externes paket in einer Konsole
▶ from lokale python datei import ein objekt
▶ [Link](eine function)

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 1.5 Module importieren TOC 44/ 145

1. Intro 1.1 Willkommen
2. Objekte 1.2 Syntax
3. Schleifen 1.3 Datentypen
4. Programmieren 1.4 Funktionen schreiben
1.5 Module importieren
1.6 Zeichenketten

Python MOOC - 1.6 Zeichenketten TOC 45/ 145

Teile von Zeichenketten auswählen (subsetting, indexing)
k = "Hallo, Welt!"
k[2:] # 3. bis letzte
k[7] # 8. Buchstabe
## 'llo, Welt!'
## 'W'
Python indiziert ab 0! k[-2] # vorletze
## 't'
k[3:7] # 4. bis 7. (rechts
exklusiv des 8.) k[-5:-2] # kombinierbar
## 'lo, ' ## 'Wel'
k[5:-2] # gemischt geht
k[:6] # 1. bis 6.
## ', Wel'
## 'Hallo,'
k[400]
## IndexError: string index out of range
k[3.5]
## TypeError: string indices must be integers
k[2] = 'K' # strings sind nicht änderbar (siehe 2.1)
## TypeError: ’str’ object does not support item assignment
Python MOOC - 1.6 Zeichenketten TOC 46/ 145
Operatoren für Zeichenketten

a = "Hallo"
len(a) # Anzahl Zeichen
## 5
"Zeichen " + "Kette " + a # zusammenfügen
## 'Zeichen Kette Hallo'
"Zeichen " + "Kette " + 77
## TypeError: can only concatenate str (not "int") to str
3 * a # wiederholen
## 'HalloHalloHallo'
3 / a
## TypeError: unsupported operand type(s) for /: ’int’
and ’str’
"lo" in a # Präsenz prüfen
## True

Python MOOC - 1.6 Zeichenketten TOC 47/ 145

Zeichenketten aufteilen und zusammenführen
zk = "Etwas Text und einige Worte"
[Link]() # Ausgabe: Liste. Standard: sep=" "
## ['Etwas', 'Text', 'und', 'einige', 'Worte']
zk # immutable: nicht verändert
## 'Etwas Text und einige Worte'
print("Zeichenkette mit\nZeilenumbruch")
## Zeichenkette mit
## Zeilenumbruch
"Zeichenkette mit\nZeilenumbruch".split(" ")
## ['Zeichenkette', 'mit\nZeilenumbruch']
"Zeichenkette mit\nZeilenumbruch".split()
## ['Zeichenkette', 'mit', 'Zeilenumbruch']
# sep Default ist jede Art von Leerzeichen, inkl. \n

"_".join(["Liste", "mit", "Worten"])

## 'Liste_mit_Worten'
Python MOOC - 1.6 Zeichenketten TOC 48/ 145
Zeichenketten mit Objektbezug: F-strings

name="Berry" ; anzahl=7
f"Ich bin {name} und habe {anzahl} Katzen."
## 'Ich bin Berry und habe 7 Katzen.'
f"Ich bin {name} und habe {anzahl+4} Katzen."
## 'Ich bin Berry und habe 11 Katzen.'

siehe [Link]

Python MOOC - 1.6 Zeichenketten TOC 49/ 145

Zusammenfassung für 1.6 Zeichenketten

Zeichenketten (strings) verarbeiten:

▶ string[position]
▶ len(string)
▶ + , * , in
▶ [Link]() , [Link]()
▶ f"string mit {Objekt} Referenz"

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 1.6 Zeichenketten TOC 50/ 145

1. Intro 2.1 Objekttypen
2. Objekte 2.2 Listen
3. Schleifen 2.3 Dictionaries
4. Programmieren

Python MOOC - 2.1 Objekttypen TOC 51/ 145

Objekte sind zum Teil veränderbar

In Python sind einige Objekte veränderbar (mutable):

eine_liste = [1,2,3]
eine_liste[1] = 99 # Listen sind veränderbar
eine_liste
## [1, 99, 3]
eine_liste.append(77) # Methode = Funktion einer Klasse
eine_liste # verändert, ohne neue Zuweisung
## [1, 99, 3, 77]

Zeichenketten sind nicht veränderbar:

kette = "Python ist toll"
kette[11] = "T"
## TypeError: ’str’ object does not support item
assignment

Python MOOC - 2.1 Objekttypen TOC 52/ 145

Tupel

▶ Ähnlich wie Listen

(4, 8, 4, -3.14)
▶ ## (4, 8, 4, -3.14)

(4, 8, "drei") # können gemischte Datentypen sein

▶ ## (4, 8, 'drei')
▶ Oft als Subelement einer Liste genutzt
▶ um verschachtelte Klammern lesbar zu halten
[(8,5), 9, 3, (4,7)]
▶ ## [(8, 5), 9, 3, (4, 7)]

Python MOOC - 2.1 Objekttypen TOC 53/ 145

Mehrfachzuweisung

Mehrfachzuweisung (multiple assignment) in einer Zeile

def eingaben_verdoppeln(x, y):
return x*2, y*2
ergebnis = eingaben_verdoppeln(3, 4)
ergebnis # ein Tupel
## (6, 8)
a, b = eingaben_verdoppeln(3, 4)
a # zwei separate Objekte
## 6
b
## 8
Tauschen zweier Variablen:
a, b = b, a # rechte Seite wird zuerst ausgeführt

Python MOOC - 2.1 Objekttypen TOC 54/ 145

Mengen (sets)
s1 = {1,2,3,4,5 }
s2 = { 3,4,5,6,7,8}
Operatoren wie in mathematischen Mengen
s1 | s2 # Vereinigung
## {1, 2, 3, 4, 5, 6, 7, 8}
s1 & s2 # Schnitt
## {3, 4, 5}
s1 - s2 # Differenz: in s1, nicht in s2
## {1, 2}
s2 - s1
## {8, 6, 7}
# zeigt, dass die Einträge nicht geordnet sind

{} # leeres Dictionary (nicht Menge!)

set() # leere Menge
Python MOOC - 2.1 Objekttypen TOC 55/ 145
Mengen haben einmalige Werte
zahlen = [6, 3, 3, 4]
Wenn Listen in ein Set konvertiert werden, sind die Einträge (mögliche
Ausprägungen) nur einmal drin:
set(zahlen)
## {3, 4, 6}

set([6, 3, "3", 4])

## {3, 4, 6, '3'}
"3" ist was anderes als 3

Neue Werte können hinzugefügt werden:

s1 = {1,2,3,4,5}
[Link](7)
s1
## {1, 2, 3, 4, 5, 7}
Python MOOC - 2.1 Objekttypen TOC 56/ 145
Objekttypen (Collections) Übersicht

Typ Beispiel änderbar geordnet indiziert Duplikate

Liste [1,3] ja ja ja ok
Tupel (1,2) nein ja ja ok
Menge {1,4} ja * nein nein nein
Dict {”a”:7, ja nein / ja seit mit nein **
”b”:6} Python 3.6 Schlüssel
*: die Elemente müssen immutable sein
**: die Schlüssel müssen einmalig sein, Werte sind mehrfach erlaubt

Liste: verschiedene Daten

Tupel: gruppieren verwandter Daten
Menge: schnelle Überprüfung, ob ein Wert enthalten ist
Dictonary: schnelles Abrufen anhand von Schlüsselnamen

Python MOOC - 2.1 Objekttypen TOC 57/ 145

Zusammenfassung für 2.1 Objekttypen

Überblick Objekte, Tupel und Mengen:

▶ Liste, Tupel, Menge, Dictionary
▶ veränderbar, geordnet
▶ Mengenoperationen

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 2.1 Objekttypen TOC 58/ 145

1. Intro 2.1 Objekttypen
2. Objekte 2.2 Listen
3. Schleifen 2.3 Dictionaries
4. Programmieren

Python MOOC - 2.2 Listen TOC 59/ 145

Liste: Erstellung + Teilmengenbildung I

liste = [7, -4, 9, 1, 2, 3, 9, 5]

len(liste)
## 8
liste[0] # erstes Element
## 7
liste[1] # zweites Element
## -4
liste[5] # Element 6
## 3
liste[2:5] # Elemente 3,4,5
## [9, 1, 2]
Bereiche sind exklusiv am rechten Ende
: ist außerhalb der Teilmengenbildung kein Operator
leere_liste = []
Python MOOC - 2.2 Listen TOC 60/ 145
Liste: Erstellung + Teilmengenbildung II
liste
## [7, -4, 9, 1, 2, 3, 9, 5]
liste[4:] # Teilung: fünftes bis letztes Element
## [2, 3, 9, 5]
liste[:6] # 1. - 6.
## [7, -4, 9, 1, 2, 3]
liste[-2] # vorletztes Element
## 9
liste[2:-3] # hier äquivalent zu liste [2:5]
## [9, 1, 2]

liste[2] = "neuerWert" # überschreibe drittes Element

liste
## [7, -4, 'neuerWert', 1, 2, 3, 9, 5]
verschiedene Datentypen möglich
Python MOOC - 2.2 Listen TOC 61/ 145
Listenelement an Index entfernen

zahlen = [1,2,3,4,5,6,7]
ende = [Link]() # letztes Element entfernen + ausgeben
ende
## 7
zahlen # verändert, ohne neue Zuweisung
## [1, 2, 3, 4, 5, 6]
[Link](3) # angegebenes Element entfernen (+ ausgeben)
zahlen
## 4
## [1, 2, 3, 5, 6]
del(zahlen[2]) # Element an Index entfernen
zahlen
## [1, 2, 5, 6]
del funktioniert auch ohne Klammern

Python MOOC - 2.2 Listen TOC 62/ 145

Listenelement nach Wert entfernen

werte = [1,2,3,4,5,6,7,4]
4 in werte # prüft ob in der Liste, gibt boolean zurück
## True
9 not in werte # prüft ob nicht in der Liste
## True
[Link](4) # Index vom ersten Auftreten von 4
## 3
[Link](4) # erste Instanz von 4 entfernen
werte
## [1, 2, 3, 5, 6, 7, 4]

Python MOOC - 2.2 Listen TOC 63/ 145

Elemente hinzufügen

[Link](66) # am Ende anfügen

werte
## [1, 2, 3, 5, 6, 7, 4, 66]
[Link](3, "neu") # an Position einfügen
werte
## [1, 2, 3, 'neu', 5, 6, 7, 4, 66]
insert verschiebt Elemente nach Eingefügtem nach hinten

zahlen + werte[:6]
## [1, 2, 5, 6, 1, 2, 3, 'neu', 5, 6]

Python MOOC - 2.2 Listen TOC 64/ 145

Listensortierung

j_liste = [7, -4, 9, 1, 2, 3]

j_liste.reverse()
j_liste
## [3, 2, 1, 9, -4, 7]
j_liste.sort()
j_liste
## [-4, 1, 2, 3, 7, 9]
j_liste.sort(reverse=True)
j_liste
## [9, 7, 3, 2, 1, -4]
k_liste = [7, -4, "9", 1, 2, 3]
k_liste.sort()
## TypeError: ’<’ not supported between instances of
’str’ and ’int’

Python MOOC - 2.2 Listen TOC 65/ 145

Listenverschachtelung + verlängerung
m_liste = [1, 2, 3, [31,32,33], 4] # Verschachtelung OK
ch_liste = ["Wörter","mit","vielen","Buchstaben"]
ch_liste[2][5] # fortlaufend indiziert: Wort 3, Buchst. 6
## 'n'

lx = [1, 2, 3, 4]
ly = [5, 6]
lz = [7, 8, 9]
[Link](ly) # ändert lx
lx
## [1, 2, 3, 4, 5, 6]
lx + ly # ändert lx nicht, dafür: lx = lx + ly
## [1, 2, 3, 4, 5, 6, 5, 6]
lz * 2
## [7, 8, 9, 7, 8, 9]
Python MOOC - 2.2 Listen TOC 66/ 145
Listen zusammenführen

woerter = ["mehrere", "Wörter"]

"\n".join(woerter)
## 'mehrere\nWörter'
print("\n".join(woerter))
## mehrere
## Wörter
gemischt = [99, "Luftballons"]
print("\n".join(gemischt))
## TypeError: sequence item 0: expected str instance,
int found
# Stern (splat) Operator entpackt Liste
print(*gemischt, sep="\n")
## 99
## Luftballons

Python MOOC - 2.2 Listen TOC 67/ 145

Listen umkehren (Aufgabe)

Korrigiere den Fehler im folgenden Code. Warum tritt er auf?

liste = ["a1", "b1", "b2", "b3", "b4", "b5", "c1", "d1"]
liste = [Link]()
print(liste[2]) # sollte "b5" sein
## TypeError: ’NoneType’ object is not subscriptable

Python MOOC - 2.2 Listen TOC 68/ 145

Listen umkehren (Lösung)

Die Listenmethode ’reverse’ ändert die Liste selbst, da das ein

veränderbares Objekt ist.
Sie wird für den Seiteneffekt aufgerufen, daher ”gibt sie nichts zurück”.
Sie gibt None zurück, was ’liste’ überschrieben hat.

liste = ["a1", "b1", "b2", "b3", "b4", "b5", "c1", "d1"]

[Link]()
print(liste[2])
## b5

Python MOOC - 2.2 Listen TOC 69/ 145

Liste kopieren für eine unabhängige Instanz
liste = [1,2,3,4,5,6]
andere_liste = liste
andere_liste
## [1, 2, 3, 4, 5, 6]
[Link](9)
andere_liste # hat sich auch verändert!
## [1, 2, 3, 4, 5, 6, 9]
Referenziert dasselbe Objekt im Arbeitsspeicher(Pointer, id(objekt) )
dritte_liste = [Link]() # unabhängige Kopie
dritte_liste
## [1, 2, 3, 4, 5, 6, 9]
liste[1] = 99
dritte_liste # wurde nicht verändert
## [1, 2, 3, 4, 5, 6, 9]
Python MOOC - 2.2 Listen TOC 70/ 145
Gültigkeitsbereich (Scope) in Funktionen (Quelle)

# Liste in einer Funktion kürzen

def maxOhne5(ll):
[Link](5)
return max(ll)
# verändert globale Liste (veränderbares Objekt)
liste_a = [1,2,3,4,5]
print(liste_a) # [1, 2, 3, 4, 5]
print(maxOhne5(liste_a)) # 4
print(liste_a) # [1, 2, 3, 4] <-- verändert!
def maxOhne5(ll):
ll = [Link]() # lokale Kopie mit andere ID
[Link](5)
return max(ll)
liste_b = [1,2,3,4,5]
print(liste_b) # [1, 2, 3, 4, 5]
print(maxOhne5(liste_b)) # 4
print(liste_b) # [1, 2, 3, 4, 5]

Python MOOC - 2.2 Listen TOC 71/ 145

Zusammenfassung für 2.2 Listen
Listen sind die Basis von allem:
▶ Indexierung (Submengen auswählen) ab 0, (slicing)
▶ gemischte Datentypen sind möglich
▶ len(liste) , [Link](index) , in , not in
▶ [Link](wert) , [Link](wert)
▶ [Link](wert) , [Link](index, wert)
▶ listeA + listeB , [Link](listeB)
▶ [Link]() , [Link]()
▶ [Link]()
▶ veränderbare Objekte innerhalb einer Funktion ändern, ändert sie
global

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.
Python MOOC - 2.2 Listen TOC 72/ 145
1. Intro 2.1 Objekttypen
2. Objekte 2.2 Listen
3. Schleifen 2.3 Dictionaries
4. Programmieren

Python MOOC - 2.3 Dictionaries TOC 73/ 145

Dictionaries

▶ speichert Daten in Form Schlüssel:Wert

▶ optimiert, Werte schnell abzurufen, wenn der Schlüssel bekannt ist
▶ Schlüssel sind einmalig, Datentyp der Werte ist egal

Nutzungsbeispiele:
▶ Produktkatalog
▶ Patienten IDs mit weiteren Informationen (kann Liste oder
Unter-Dictionary sein)
▶ HTTP-Statuscodes
▶ Kontaktliste (Telefonbuch)
▶ Warenkorb in Onlineshops

Python MOOC - 2.3 Dictionaries TOC 74/ 145

Dictionaries

dozent = {'Name': "Berry",

'Alter': 32}
len(dozent)
## 2
dozent['Name'] # Zugriff auf einen Eintrag
## 'Berry'
dozent['Alter'] = 33 # Eintrag überschreiben
dozent
## {'Name': 'Berry', 'Alter': 33}
dozent['Studis'] = 42 # Eintrag hinzufügen
dozent
## {'Name': 'Berry', 'Alter': 33, 'Studis': 42}

Python MOOC - 2.3 Dictionaries TOC 75/ 145

Namenskonvention

Ich benutze ’ Apostrophen in Dictionaries, da sie in f-strings mit ”

Anführungszeichen benutzt werden können.
Doppelte und einfache Anführungszeichen können im F-string nicht
gemischt werden.
f"Erstelle einen String mit {3+4} Berechnungen."
## 'Erstelle einen String mit 7 Berechnungen.'
f"Hi {dozent['Name']}, du bist {dozent['Alter']} Jahre
alt."
## 'Hi Berry, du bist 33 Jahre alt.'
Seit Python 3.12 (2023-10) ist das doch möglich.

Python MOOC - 2.3 Dictionaries TOC 76/ 145

Zugriff auf Dictionaries

fehlersichere Auswahl eines Schlüssels:

[Link]('Name', "Wert falls Schlüssel fehlt")
## 'Berry'
[Link]('NAME', "Wert falls Schlüssel fehlt")
## 'Wert falls Schlüssel fehlt'
[Link]() # Quasi eine Liste als Ausgabe
## dict_keys(['Name', 'Alter', 'Studis'])
[Link]() # [Link]() zum Iterieren
## dict_values(['Berry', 33, 42])
"Alter" in [Link]()
## True
"Alter" in dozent # kürzer und schneller :)
## True

Python MOOC - 2.3 Dictionaries TOC 77/ 145

Elemente aus einem Dictionary entfernen
dozent = {'Name':"Berry", 'Alter':32, 'Studis':42, 'z':0}
del(dozent['Alter']) # entfernt kompletten Eintrag
dozent
## {'Name': 'Berry', 'Studis': 42, 'z': 0}
studis = [Link]('Studis')
studis
## 42
dozent
## {'Name': 'Berry', 'z': 0}
[Link]('Alter') # Schlüssel nicht mehr da
## KeyError: ’Alter’
[Link]('Alter', None) # gibt None zurück
[Link]() # Alle Einträge entfernen
dozent
## {}
Python MOOC - 2.3 Dictionaries TOC 78/ 145
Dictionary: Zeiger (memory pointer) und Kopien

dict1 = {'a': 1, 'b': 2, 'c': 3}

dict2 = dict1 # dict2 ist nur ein Zeiger auf dict1
dict3 = [Link]() # unabhängige Kopie
Wenn man dict1 verändert, ändert sich auch dict2 .
(Das gilt für alle veränderbaren Objekte).
dict1['c'] = 333
dict2
## {'a': 1, 'b': 2, 'c': 333}
dict3
## {'a': 1, 'b': 2, 'c': 3}

Python MOOC - 2.3 Dictionaries TOC 79/ 145

Dictionaries aktualisieren

dict1 = {'a': 1, 'b': 2, 'c': 3}

dict2 = {'a': 11, 'd': 4}
[Link](dict2) # aktualisiert Werte oder fügt
Einträge hinzu
dict1
## {'a': 11, 'b': 2, 'c': 3, 'd': 4}

Python MOOC - 2.3 Dictionaries TOC 80/ 145

Dictionary formatiert ausgeben

dozent = {'Name': "Berry", 'Alter' : 32}

for k, v in [Link]():
print("Der Eintrag '",k,"' hat den Wert: ",v, sep="")
## Der Eintrag 'Name' hat den Wert: Berry
## Der Eintrag 'Alter' hat den Wert: 32

Nächste Woche behandeln wir For-Schleifen :)

Python MOOC - 2.3 Dictionaries TOC 81/ 145

Zusammenfassung für 2.3 Dictionaries

dictionaries (Schlüssel-Wert Paare):

▶ dict = {’Schluessel’:"Wert"}
▶ dict[’Schluessel’]
▶ [Link](’Schluessel’, "Ersatz")
▶ ’Schlüssel’ in dict
▶ [Link](’Schluessel’, "Ersatz") , [Link]()
▶ [Link]()
▶ [Link](dictB)

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 2.3 Dictionaries TOC 82/ 145

1. Intro 3.1 Bedingte Codeausführung
2. Objekte 3.2 For- und While-Schleifen
3. Schleifen 3.3 List comprehension
4. Programmieren

Python MOOC - 3.1 Bedingte Codeausführung TOC 83/ 145

Vergleichende und logische Operatoren
vergleichende Operatoren:
wert = 8
a == b # ist a gleich b? 7 < wert < 9 # nice!
a != b # ungleich? ## True
a < b # kleiner als 7 < 8
a <= b # kleiner / gleich "9" < "A"
a > b # größer als "A" < "B" # alle
a >= b # größer / gleich "a" < "b" # True
"A" < "a"
Kommazahlen gerundet vergleichen: # zahl < GROß < klein
summe = 5.1 + 1.1
summe == 6.2 logische Operatoren:
## False not False # NICHT
round(summe,8) == round(6.2, 8) ## True
## True True and 6 > 8 # UND
import math ## False
[Link](summe, 6.2) 9 > 8 or False # ODER
## True ## True
Python MOOC - 3.1 Bedingte Codeausführung TOC 84/ 145
Achtung vor bit-Operatoren

7>1 & 6>1

## False
& ist ein Bit-Operator!
(Nicht der UND-Operator wie in anderen Programmiersprachen)
7>1 and 6>1
## True
Das gilt auch für das Zirkumflex (ˆ):
2^3 # ist eigentlich 8
## 1
^ ist ein binäres XOR (ausschließliches ODER)
siehe stackoverflow / Was macht der Zirkumflex-Operator
& führt bitweise UND Operation auf Bits aus
siehe Wikipedia / Bitweise Operatoren

Python MOOC - 3.1 Bedingte Codeausführung TOC 85/ 145

Bedingte Codeausführung: allgemeine Struktur
a = 10 ; b = 20
if b > a:
print("b ist größer als a")
## b ist größer als a
a = 30 ; b = 30
if b > a:
print("b ist größer als a")
elif a == b:
print("a und b sind gleich")
## a und b sind gleich
a = 100 ; b = 30
if b > a:
print("b ist größer als a")
elif a == b:
print("a und b sind gleich")
else:
print("a ist größer als b")
## a ist größer als b
Python MOOC - 3.1 Bedingte Codeausführung TOC 86/ 145
Bedingte Codeausführung: Bedingungen kombinieren

a = 100 ; b = 30
if a>b and (b==20 or b==30):
print("a ist größer und b ist 20 oder 30")
## a ist größer und b ist 20 oder 30

cond = [True, False, True, True, True]

all(cond) # alle wahr?
## False
any(cond) # mindestens 1 wahr?
## True
sum(cond) # Anzahl wahr
## 4

Python MOOC - 3.1 Bedingte Codeausführung TOC 87/ 145

Bedingte Codeausführung in einer Funktion: Übersicht

Für eine Vierfeldertafel gibt es zwei Ansätze

mit return , verschachtelt, ohne elif :

if cond1:
if cond2: return "tt" # Zeilenumbrüche vor return
else: return "tF" # aus Platzgründen
if cond2: return "Ft" # weggelassen. In echt bitte
else: return "FF" # setzen für den style guide

mit print , eine Ebene, mit and + elif :

if cond1 and cond2: print("tt")
elif cond1: print("tF")
elif cond2: print("Ft")
else: print("FF")

Python MOOC - 3.1 Bedingte Codeausführung TOC 88/ 145

Bedingte Codeausführung - Mathe-Beispiel

Quelle mit n=1 & inf als Grenzen:

2x wenn x < 0.5
f(x) = 1-2(x-0.5) wenn 0.5 <= x <= 1
0 wenn x > 1
x = -0.2
if x>1:
y = 0
elif x >= 0.5:
y = 2-2*x
else:
y = 2*x
print(y)
## -0.4
Python MOOC - 3.1 Bedingte Codeausführung TOC 89/ 145
Bedingte Codeausführung - input-Beispiel

username = input('Gib deinen Nutzernamen ein: ')

password = input('Gib dein Passwort ein: ')
Gib Login erfolgreich aus für den Nutzer admin mit Passwort
123456, sonst Nutzername oder Passwort sind falsch
if username == 'admin' and password == '123456':
print('Login erfolgreich')
else:
print('Nutzername oder Passwort sind falsch')

Python MOOC - 3.1 Bedingte Codeausführung TOC 90/ 145

Bedingte Codeausführung - Schaltjahr-Beispiel

Ein Schaltjahr ist ein Kalenderjahr, das einen zusätzlichen Tag (29.
Februar) enthält, um im Gleichschritt mit dem astrononomischen Jahr zu
bleiben. Diese zusätzlichen Tage treten in jedem Jahr auf, welches ein
Vielfaches von 4 ist, außer den Jahren, welche Vielfache von 100 sind, es
sei denn, sie sind auch durch 400 teilbar.

Finde heraus, ob ein Jahr ein Schaltjahr ist.

Der Modulo-Operator ist % .
Das Jahr sollte durch 4 teilbar sein und (nicht teilbar durch 100 oder
teilbar durch 400)
jahr = int(input('Gib das Jahr ein: '))
ist_schalt = jahr%4==0 and jahr%100!=0 or jahr%400==0
print(ist_schalt)

Python MOOC - 3.1 Bedingte Codeausführung TOC 91/ 145

Zusammenfassung für 3.1 Bedingte Codeausführung
Logik und Bedingte Codeausführung:
▶ Vergleichsoperatoren, min < value < max , not , and , or
▶ & und ^ sind bitweise Operatoren, nicht verwenden (außer das ist
beabsichtigt)
▶ Struktur bedingten Codes:
if bedingung1:
ausdruck1
elif bedingung2:
ausdruck2
else:
ausdruck3
▶ all , any , sum

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.
Python MOOC - 3.1 Bedingte Codeausführung TOC 92/ 145
1. Intro 3.1 Bedingte Codeausführung
2. Objekte 3.2 For- und While-Schleifen
3. Schleifen 3.3 List comprehension
4. Programmieren

Python MOOC - 3.2 For- und While-Schleifen TOC 93/ 145

Schleifen: Anweisungen wiederholen

Code mehrfach ausführen, jeweils mit einem anderen Wert

Nachfolgender Code hat viele Dopplungen:

print(list(range(1,4)))
print(list(range(1,5)))
print(list(range(1,9)))

Das geht einfacher mit einer Schleife:

for ende in [4,5,9]:
print(list(range(1,ende)))
## [1, 2, 3]
## [1, 2, 3, 4]
## [1, 2, 3, 4, 5, 6, 7, 8]

Python MOOC - 3.2 For- und While-Schleifen TOC 94/ 145

Schleifenstruktur

for variable in werte_liste :

mach_etwas_mit(variable)
# Doppelpunkt (:) wird benötigt
# Einrückung ist wichtig
while bedingung_erfuellt:
fuehre_dinge_aus_die_ggf_die_bedingung_aendern()
if diesmal_fertig:
continue # springe zur nächsten Iteration
if ganz_fertig:
break # brich die Schleife ab
nur_ausfuehren_wenn_beide_FERTIGs_falsch_sind()

Konvention für eine nicht verwendete Indexvariable:

for _ in range(3):
print("kram") # -> kram kram kram

Python MOOC - 3.2 For- und While-Schleifen TOC 95/ 145

for-loop print-Beispiel 1

for zahl in (0,1,2,3):

print(zahl)
## 0
## 1
## 2
## 3
for zahl in range(4):
print(zahl)
## 0
## 1
## 2
## 3
list( range(8, 0, -2) ) # range Ende exklusiv
## [8, 6, 4, 2]

Python MOOC - 3.2 For- und While-Schleifen TOC 96/ 145

for-loop print-Beispiel 2
Zeige alle Objektnamen eines Moduls auf einer jeweils eigenen Zeile an:
import math # eingebautes Modul (Paket)
for f in dir(math):
print(f)
## __doc__
## ... # manuell ausgewählte Ausgabe
## __name__
## __package__
## acos
## ceil
## exp
## factorial
## gamma
## inf
## isnan
## log10
## pi
## pow
## sin
## sqrt
Python MOOC - 3.2 For- und While-Schleifen TOC 97/ 145
for-Schleife Maximum-Beispiel

werte = [923,790,447,617,534,93,895,60,21,
962,992,302,435,902,795,482]
Stell dir vor, die Funktion max wäre nicht verfügbar.
Bestimme den größten Wert mithilfe einer Schleife.
maxi = 0
for w in werte:
if w > maxi:
maxi = w
print(maxi)
## 992

Python MOOC - 3.2 For- und While-Schleifen TOC 98/ 145

for-loop Auswahl-Beispiel

Wähle alle geraden Zahlen aus einer Liste aus.

zahlen = [468,976,701,269,841,7,917,698,689,526,307,791,718]
gerade = [] # leere Liste initiieren
for n in zahlen:
if n%2==0:
[Link](n)
gerade
## [468, 976, 698, 526, 718]

Python MOOC - 3.2 For- und While-Schleifen TOC 99/ 145

Mehrere Iteratoren

Mehrere Objekte in einer Codezeile (siehe 2.1 Objekttypen)

for a,b in [(1,11), (2,22), (3,33), (4,44)]:
print("a:", a, " b:", b, "-> Ergebnis:", b-2*a)
## a: 1 b: 11 -> Ergebnis: 9
## a: 2 b: 22 -> Ergebnis: 18
## a: 3 b: 33 -> Ergebnis: 27
## a: 4 b: 44 -> Ergebnis: 36

Python MOOC - 3.2 For- und While-Schleifen TOC 100/ 145

while-loop print-Beispiel

So lange das geld ausreicht, Sachen kaufen (und Restbetrag anzeigen)

geld = 53
while geld > 10:
print(geld)
geld -= 10
print("finaler Wert:", geld)
## 53
## 43
## 33
## 23
## 13
## finaler Wert: 3

Python MOOC - 3.2 For- und While-Schleifen TOC 101/ 145

while-loop input-Beispiel
wiederholt eine Zahl per input abfragen, bis sie korrekt erraten wurde
zahl = 0
while zahl != 42 :
zahl = input("Rate eine Zahl: ")
zahl = int(zahl)
if zahl==42:
print("Du hast die Antwort (auf alles) gefunden.")
elif zahl > 42: # print(..., flush=True) in Rstudio
print(f"Tut mir leid, {zahl} ist zu groß.")
else:
print(f"Tut mir leid, {zahl} ist zu klein.")
## Rate eine Zahl: 78
## Tut mir leid, 78 ist zu groß.
## Rate eine Zahl: 31
## Tut mir leid, 31 ist zu klein.
## Rate eine Zahl: 42
## Du hast die Antwort (auf alles) gefunden.
Python MOOC - 3.2 For- und While-Schleifen TOC 102/ 145
while-loop input-Alternative

while(True):
zahl = input("Rate eine Zahl: ")
zahl = int(zahl)
if zahl==42:
print("Du hast die Antwort (auf alles) gefunden.")
break
elif zahl > 42:
print(f"Tut mir leid, {zahl} ist zu groß.")
else:
print(f"Tut mir leid, {zahl} ist zu klein.")
while(True) beginnt eine Schleife, die manuell beendet werden muss
(mittels break , in einer Funktion geht auch return )

Python MOOC - 3.2 For- und While-Schleifen TOC 103/ 145

Schleifensteuerung (control commands) Beispiele

for buchstabe in 'Python': # strings sind iterierbar :)

if buchstabe == 'h':
continue # überspringe den Rest einer Ausführung
print("Aktuell: " + buchstabe)
## Aktuell: P
## Aktuell: y
## Aktuell: t
## Aktuell: o
## Aktuell: n
for buchstabe in 'Python':
if buchstabe == 'h':
break # die Schleife vollständig abbrechen
print("Aktuell: " + buchstabe)
## Aktuell: P
## Aktuell: y
## Aktuell: t
Python MOOC - 3.2 For- und While-Schleifen TOC 104/ 145
Abbildung (mapping)

buchstabenliste = ["abcdef", "ab", "abc"]

buchstabenlaenge = []
for b in buchstabenliste:
[Link](len(b))
buchstabenlaenge
## [6, 2, 3]
b_laenge = map(len, buchstabenliste)
b_laenge
## <map object at 0x000001E51057F760>
list(b_laenge)
## [6, 2, 3]

list(map(len, buchstabenliste))
# ist viel kürzer als die Schleife oben :)

Python MOOC - 3.2 For- und While-Schleifen TOC 105/ 145

Objekte in Schleifen ändern 1
ids = ["a1","b1","b2","b3","b4","b5","b6","c1","d1"]
# Entferne Werte, die mit b starten
for v in ids:
if v[0]=="b": [Link](v)
ids
## ['a1', 'b2', 'b4', 'b6', 'c1', 'd1']
Warum ist die Hälfte der b’s noch drin?
Nach der zweiten Iteration ist ids a1, b2, b3, b4, b5, b6, c1, d1 ,
weil ”b1” entfernt wurde. In der dritten Iteration wertet Python ’ids’
wieder aus und gibt das dritte Element an v (”b3”). Dieses wird
wieder entfernt, also verbleiben a1, b2, b4, b5, b6, c1, d1 . Das
wiederholt sich, bis wir bei a1, b2, b4, b6, c1, d1 ankommen. Ein
Index hilft nicht: for i in range(len(ids)) gibt einen IndexError.
Wie können wir korrekt in einer Schleife die Werte auswählen, die nicht
mit b beginnen?
Python MOOC - 3.2 For- und While-Schleifen TOC 106/ 145
Objekte in Schleifen ändern 2
ids = ["a1","b1","b2","b3","b4","b5","b6","c1","d1"]
ausgabe = []
for v in ids:
if v[0]!="b": [Link](v)
print(ausgabe)
## ['a1', 'c1', 'd1']
Das Iteratorobjekt in einer Schleife darf nicht verändert werden!
Unerwartete Dinge: Iteration in Python
Es gibt hier eine Alternative, die (scheinbar) ohne Schleife auskommt:
def beginnt_nicht_mit_b(x):
return x[0]!="b"
list(filter(beginnt_nicht_mit_b, ids))
## ['a1', 'c1', 'd1']
list(filter(lambda x : x[0]!="b", ids))
## ['a1', 'c1', 'd1']
Python MOOC - 3.2 For- und While-Schleifen TOC 107/ 145
Zusammenfassung für 3.2 For- und While-Schleifen
for- und while-Schleifen :
▶ Schleifenstruktur:
for var in liste:
ausdruck(var)
▶ continue , break
▶ for in range(n): für ungenutzte Variable
▶ for x,y in [(x1,y1),(x2,y2)]:
▶ list(map(funktion, liste))
▶ list(filter(funktion, liste))
▶ Verändere nicht das Iterator-Objekt während Iteration
▶ Im echten Leben: map/filter, list comprehension, pandas

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.
Python MOOC - 3.2 For- und While-Schleifen TOC 108/ 145
1. Intro 3.1 Bedingte Codeausführung
2. Objekte 3.2 For- und While-Schleifen
3. Schleifen 3.3 List comprehension
4. Programmieren

Python MOOC - 3.3 List comprehension TOC 109/ 145

List comprehension (Codelänge verringern) - Beispiel 1

def tu_etwas_mit(x):
return x + 5
einige_zahlen = [6, 9, 17, -2, 24]

ergebnis = []
for zahl in einige_zahlen:
neue_zahl = tu_etwas_mit(zahl)
[Link](neue_zahl)
ergebnis
## [11, 14, 22, 3, 29]
ergebnis = [tu_etwas_mit(zahl) for zahl in einige_zahlen]
ergebnis
## [11, 14, 22, 3, 29]
list(map(tu_etwas_mit, einige_zahlen))
## [11, 14, 22, 3, 29]
Python MOOC - 3.3 List comprehension TOC 110/ 145
List comprehension (Codelänge verringern) - Beispiel 2

namen = ["Alex","Berry","Beth","Chris","Dave"]
mitB = []
for wort in namen:
if wort[0] == "B":
[Link](wort)
mitB
## ['Berry', 'Beth']
mitB = [wort for wort in namen if wort[0] == "B"]
mitB
## ['Berry', 'Beth']

Python MOOC - 3.3 List comprehension TOC 111/ 145

Dictionary comprehension funktioniert auch so
# Gib die Buchstabenzahl jedes Wortes aus:
nachricht = "du steigerst dich"
{wort:len(wort) for wort in [Link]()}
## {'du': 2, 'steigerst': 9, 'dich': 4}
# Verdopple jeden Wert im Dictionary:
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}
doppel_dict1 = {k:v*2 for (k,v) in [Link]()}
# Wähle alle geraden Einträge, die größer als 2 sind:
{k:v for (k,v) in [Link]() if v>2 and v%2==0}
## {'d': 4, 'f': 6}
# Wandle von Grad Fahrenheit nach Celcius um:
dF = {'t1': -30, 't2': -20, 't3': -10, 't4': 0}
dC = {k:5/9*float(v-32) for (k,v) in [Link]()}
dC = {k+"C":round(v) for (k,v) in [Link]()}
dC
## {'t1C': -34, 't2C': -29, 't3C': -23, 't4C': -18}
Python MOOC - 3.3 List comprehension TOC 112/ 145
List comprehension Übung
Kürze alle drei Schleifen auf eine einzelne Codezeile.
werte = [11,10,2,3,15,3,5,7,7,2,8,7,5,6,5,8,5,9,6,3,15,6,9]
quadratsumme = 0
for v in werte:
quadratsumme += v**2
quadratsumme
## 1351
zahlen = [951,402,984,651,360,69,408,319,601,485,980,507,725,
547,544,615,83,165,141,501,263,617,865,575,219,390,984,592,236,
105,942,941,386,462,47,418,907,344]
gerade_zahlen = []
for n in zahlen:
if n%2==0: gerade_zahlen.append(n)
gerade_zahlen
## [402, 984, 360, 408, 980, 544, 390, 984, 592, 236, 942, 386, 462, 418, 344]
import random
max_exp = []
for i in range(50):
max_exp.append([Link](0.2))
max_exp = max(max_exp)
max_exp
## 20.343037401675073
Python MOOC - 3.3 List comprehension TOC 113/ 145
List comprehension Übungslösungen

werte = [11,10,2,3,15,3,5,7,7,2,8,7,5,6,5,8,5,9,6,3,15,6,9]
sum([v**2 for v in werte])
## 1351
zahlen = [951,402,984,651,360,69,408,319,601,485,980,507,725,
547,544,615,83,165,141,501,263,617,865,575,219,390,984,592,236,
105,942,941,386,462,47,418,907,344]
[n for n in zahlen if n%2==0]
## [402, 984, 360, 408, 980, 544, 390, 984, 592, 236, 942, 386, 462, 418, 344]
import random
max([[Link](0.2) for _ in range(50)])
## 19.221103122473906

Python MOOC - 3.3 List comprehension TOC 114/ 145

Zusammenfassung für 3.3 List comprehension

Schleifen-code deutlich verkürzen:

▶ Listen- und Dict comprehension
▶ [tu etwas mit(x) for x in liste if bedingung(x)]
▶ {k:tu etwas mit(v) for (k,v) in eine [Link]()}

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 3.3 List comprehension TOC 115/ 145

1. Intro 4.1 Fehlermanagement
2. Objekte 4.2 Eigene Klassen schreiben
3. Schleifen 4.3 Unit Tests
4. Programmieren

Python MOOC - 4.1 Fehlermanagement TOC 116/ 145

Fehlermanagement: try - except
Bei einem Fehler bricht die komplette Programmausführung ab.
Beispiel: TypeError: falscher Datentyp für Operator oder Funktion
ergebnis_einer_berechnung = "2"
7 + ergebnis_einer_berechnung
## TypeError: unsupported operand type(s) for +: ’int’
and ’str’

Python kann Code aber auch probeweise ausführen, und im Fall eines
Fehlers was anderes machen als abbrechen.
try:
7 + ergebnis_einer_berechnung
except TypeError:
print("Zeichenkette und Nummer gemischt")
## Zeichenkette und Nummer gemischt
Beachte die Einrückung, wie mit allen Python Kontrollstrukturen
Python MOOC - 4.1 Fehlermanagement TOC 117/ 145
generisches except

try:
7 + nichtExistierendesObjekt
except TypeError:
print("Zeichenkette und Nummer gemischt")
except:
print("Ein Fehler ist aufgetreten")
## Ein Fehler ist aufgetreten

Python MOOC - 4.1 Fehlermanagement TOC 118/ 145

else

try:
7 + "2" # Code mit möglichen Fehlern
except:
print("Code fehlgeschlagen")
else:
print("Code erfolgreich ausgeführt")
## Code fehlgeschlagen
Der else Code wird ausgeführt, wenn keine Fehler auftreten. Könnte
auch im try Teil sein, man sollte aber den potentiellen Fehler und den
Umgang damit nah beieinander behalten. Fange nur erwartete Fehler ab
(andere Fehler sollten weiterhin auftreten).
else wird vor finally ausgeführt (nächste Folie).

Python MOOC - 4.1 Fehlermanagement TOC 119/ 145

finally

try:
7 + "2" # Code mit möglichen Fehlern
except:
print("Code fehlgeschlagen")
finally:
print("Programm fertig")
## Code fehlgeschlagen
## Programm fertig
Code in finally wird ausgeführt, selbst wenn return / break / continue
aufgerufen wird oder ein anderer (nicht abgefangener) Fehler auftritt.

Python MOOC - 4.1 Fehlermanagement TOC 120/ 145

traceback

traceback gibt aus, woher der Fehler kommt:

import traceback
try:
7 + nichtExistierendesObjekt
except:
print("Fehler aufgetreten:",traceback.format_exc())
## Fehler aufgetreten: Traceback (most recent call last):
## File "<string>", line 2, in <module> ## NameError:
name ’nichtExistierendesObjekt’ is not defined
informativer in echter Anwendung (Folienstruktur kann kein traceback).
IDEs mit Debugger stellen oft tracebacks für Fehler zur Verfügung

Python MOOC - 4.1 Fehlermanagement TOC 121/ 145

Exception Objekt

Fehler mit benutzerdefiniertem Präfix protokollieren

def addiere7_mit_print_statt_fehler(x):
try:
return x + 7
except Exception as e: # Fehlermeldung als Variable 'e'
print("Ein Fehler ist aufgetreten:",e, sep="\n")
addiere7_mit_print_statt_fehler(3)
## 10
addiere7_mit_print_statt_fehler("3")
## Ein Fehler ist aufgetreten:
## can only concatenate str (not "int") to str
addiere7_mit_print_statt_fehler(None)
## Ein Fehler ist aufgetreten:
## unsupported operand type(s) for +: 'NoneType' and 'int'

Python MOOC - 4.1 Fehlermanagement TOC 122/ 145

Exception info

def fehler_mit_ganzer_nachricht(x): # siehe auch

try: # sys.exc_info()
x + 7
except Exception as e:
print(f"Ein {type(e).__name__} ist passiert:\n{e}")
fehler_mit_ganzer_nachricht(3)
fehler_mit_ganzer_nachricht(None)
## Ein TypeError ist passiert:
## unsupported operand type(s) for +: 'NoneType' and 'int'
fehler_mit_ganzer_nachricht("3")
## Ein TypeError ist passiert:
## can only concatenate str (not "int") to str
fehler_mit_ganzer_nachricht(dummyvar)
## NameError: name ’dummyvar’ is not defined

Python MOOC - 4.1 Fehlermanagement TOC 123/ 145

Zeitstempel

Nachrichten mit Zeitstempel, nützlich für Logging (protokollieren)

import time
jetzt = [Link]("%Y-%m-%d %H:%M UTC", [Link]())
print(jetzt)
## 2024-10-15 08:25 UTC
def fehler_mit_zeitstempel(x):
try:
x + 7
except:
n = [Link]("%Y-%m-%d %H:%M UTC",[Link]())
print("Ein Fehler ist aufgetreten am:", n)
fehler_mit_zeitstempel(3)
fehler_mit_zeitstempel(None)
## Ein Fehler ist aufgetreten am: 2024-10-15 08:25 UTC

Python MOOC - 4.1 Fehlermanagement TOC 124/ 145

Fehlermanagement Beispiel

preis = None
while not isinstance(preis, int):
try:
preis = int(input("Gib einen Preis ein: "))
except ValueError:
print("Bitte gib eine gültige Nummer ein.")
print("Die eingegebene Nummer war: ", preis)

Python MOOC - 4.1 Fehlermanagement TOC 125/ 145

Zusammenfassung für 4.1 Fehlermanagement
Exceptions abfangen und verwalten:
▶ Struktur
try:
code_mit_moeglichen_Fehlern
except BestimmterError: # möglichst nur konkrete
was_jetzt_zu_tun_ist # Fehler abfangen!
except Exception as e:
mach_etwas_damit(e) # z.B. Logging
traceback.format_exc()
[Link]("%Y-%m-%d %H:%M UTC", [Link]())
except: # falls Excpetion as e
andere_Fehler_behandeln # nicht genutzt wurde
else:
was_zu_tun_ist_falls_BestimmterError_nicht_passiert
finally:
tu_das_immer_am_Ende
Melde unklare Aufgaben im Forum.
Markiere die Inhalte dieser Lektion in deiner RefCard.
Python MOOC - 4.1 Fehlermanagement TOC 126/ 145
1. Intro 4.1 Fehlermanagement
2. Objekte 4.2 Eigene Klassen schreiben
3. Schleifen 4.3 Unit Tests
4. Programmieren

Python MOOC - 4.2 Eigene Klassen schreiben TOC 127/ 145

Benutzerdefinierte Klassen

Ein paar Definitionen:

Objekt: Sammlung von Daten (Variablen) und Methoden (Funktionen)
die auf Basis dieser Daten operieren. (Attribute + Verhalten)
Klasse: Vorlage für Objekte
Instanz: spezifisches Objekt einer Klasse
class Person:
pass
Python verbietet leere Körper in Klassen. Das pass Statement dient als
Platzhalter für Code
p1 = Person() # erstellt Instanz der Klasse Person
[Link] = "Berry" ; [Link] = 32 # Attribute hinzufügen
p1
## <__main__.Person object at 0x000001EFD04EB9D0>
p1.__dict__ # Dictionary mit allen Attributen
## {'name': 'Berry', 'alter': 32}

Python MOOC - 4.2 Eigene Klassen schreiben TOC 128/ 145

Benutzerdefinierte Klasse definieren

class Person:
def __init__(self, name, alter):
[Link] = name
[Link] = alter
person1 = Person('Berry', 23) # konstruiert neue Person
person2 = Person('Christina', 16)
[Link]
## 'Berry'
init : spezielle Funktion die beim Erstellen des Objekts aufgerufen
wird und die Attribute initialisiert. Sie wirkt wie ein Konstruktor.
self: steht für die Instanz der Klasse, mit der wir die Methode aufrufen.
Es ist das erste Argument von Methoden wie init .
Objekte person1 und person2 haben eigene Attribute (name, alter).
Mit dem self Argument können die Methoden auf Attribute der
spezifischen Instanz zugreifen.

Python MOOC - 4.2 Eigene Klassen schreiben TOC 129/ 145

Methoden einer benutzerdefinierten Klasse
eine Methode, die überprüft ob eine Person Horrorfilme schauen darf:
class Person:
def __init__(self, name, alter):
[Link] = name
[Link] = alter
def darf_horrorfilm_sehen(self): # diese Funktion
if [Link] >= 18: # ist eine Methode
return "los gehts!" # für alle Objekte
else: # der Klasse ‘Person‘
return "sorry, zu jung"
person1 = Person('Berry', 23)
person1.darf_horrorfilm_sehen()
## 'los gehts!'
person2 = Person('Christina', 16)
person2.darf_horrorfilm_sehen()
## 'sorry, zu jung'
Python MOOC - 4.2 Eigene Klassen schreiben TOC 130/ 145
Übung und Ressourcen

Wie kann man die Methode darf horrorfilm sehen vereinfachen,

sodass sie True / False zurückgibt?

def darf_horrorfilm_sehen(self):
return [Link] >= 18

Weiterführende Materialien:
Dr Philip Yip
Python101
Pynative

Python MOOC - 4.2 Eigene Klassen schreiben TOC 131/ 145

Klasse mit Eingabeüberprüfung
class Patient:
def __init__(self, pid, geschlecht, BD):
[Link] = pid
[Link] = geschlecht
[Link] = BD
if geschlecht not in ["m","w","d"]:
raise ValueError("geschlecht muss m/w/d sein")
def hat_bluthochdruck(self):
return [Link] > 130
Patient(pid="Pat456", geschlecht="Divers", BD=120)
## ValueError: geschlecht muss m/w/d sein

armer_kerl = Patient("Pat123", "m", 113)

armer_kerl.BD = 150
print("jetzt behandeln:", armer_kerl.hat_bluthochdruck())
## jetzt behandeln: True
Python MOOC - 4.2 Eigene Klassen schreiben TOC 132/ 145
Klassenvariablen, siehe z.B. [Link]
class Student:
anzahl = 0 # Klassenvariable
def __init__(self, name):
[Link] = name
[Link] += 1 # bei jeder Erstellung + 1
s1 = Student("Anna Lena")
s2 = Student("Christina")
Student("Berry")
[Link]
## 3
[Link] # Instanzvariable greift auf Klassenvariable zu
## 3
[Link] = 1000
[Link] # unabhängig einer einzelnen Instanz
## 3
Python MOOC - 4.2 Eigene Klassen schreiben TOC 133/ 145
Klassen (Aufgabe + Teillösung)
Herons Formel ergibt die Fläche eines Dreiecks, wenn die Länge aller drei
Seiten bekannt ist. Eine Seite eines Dreiecks kann nicht länger sein als
die Summe der beiden Anderen. Schreibe Code, der die Fläche ausgibt -
oder ”Kein Dreieck”, wenn eine Seite zu lang ist.
halbperimeter s = (a+b+c)/2 flaeche a = sqrt(s(s-a)(s-b)(s-c))
a = 10
b = 4
c = 5
if a+b > c and a+c > b and b+c >a:
s = (a+b+c)/2
flaeche = (s*(s-a)*(s-b)*(s-c))**0.5 #**0.5 = sqrt
f"Flaeche des Dreiecks: {flaeche}"
else:
"Kein Dreieck"
Schreibe eine Dreieck Klasse, die einen Fehler für ungültige Dreiecke
erzeugt und eine Flächenmethode hat.
Python MOOC - 4.2 Eigene Klassen schreiben TOC 134/ 145
Klassen Aufgaben (Lösung)
class Dreieck:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
if not(a+b > c and a+c > b and b+c >a):
raise ValueError('ungültig: zu lange Seite')
def flaeche(self):
p = (self.a+self.b+self.c)/2
flaeche = (p*(p-self.a)*(p-self.b)*(p-self.c))**0.5
return flaeche
eck = Dreieck(a=3, b=4, c=5)
eck.__dict__ # Attribute ausgeben
## {'a': 3, 'b': 4, 'c': 5}
[Link]()
## 6.0
Python MOOC - 4.2 Eigene Klassen schreiben TOC 135/ 145
Zusammenfassung für 4.2 Eigene Klassen schreiben

Benutzerdefinierte Klassen:
▶ generelle Struktur:
class MeineKlasse:
classVariable = "wert"
def __init__(self, args):
[Link] = args
if not gueltig(args): raise SomeError("info")
def eineMethode(self):
return [Link]

eineInstanz = MeineKlasse("werte")
[Link]()

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.

Python MOOC - 4.2 Eigene Klassen schreiben TOC 136/ 145

1. Intro 4.1 Fehlermanagement
2. Objekte 4.2 Eigene Klassen schreiben
3. Schleifen 4.3 Unit Tests
4. Programmieren

Python MOOC - 4.3 Unit Tests TOC 137/ 145

Warum Testen?

▶ Beim Programmieren können unbemerkt Fehler entstehen und sich

im Code manifestieren.
▶ Diese Fehler können zu unerwartetem Verhalten oder gar einem
Programmabbruch führen.
▶ Manuelles Ausprobieren aller möglichen Fälle wird zunehmend
aufwändig und unübersichtlich.
▶ Daher: automatisiertes Testen

Python MOOC - 4.3 Unit Tests TOC 138/ 145

Testverfahren

▶ Statische Testverfahren (= ohne Codeausführung)

▶ Code-Reviews (durch Kolleg:innen, neuerdings durch KI)
▶ Quellcodeanalyse (z.B. PyLint)
def addiere(a, b):
summe = a + b
return a + b
## warning (W0612, unused-variable, addiere) Unused
variable ’summe’
▶ Dynamische Testverfahren (= mit Codeausführung)
▶ Unit Tests (z.B. mit PyUnit)
▶ Integration Tests (z.B. mit PyUnit)
▶ System Tests (z.B. Selenium für Webanwendungen)
▶ Acceptance Tests (z.B. Selenium, Robot Framework)

Python MOOC - 4.3 Unit Tests TOC 139/ 145

Beispiel - ”zuletzt gesehen”

Eine Chatanwendung soll anzeigen, wann eine Person zuletzt online war.
Die Anzeige soll in Minuten / Stunden / Tagen erfolgen.

Skript [Link] mit folgender naiver Umsetzung:

def zuletzt_gesehen(sek):
if sek == 0:
return "Online"
elif sek < 60:
return "Zuletzt vor weniger als 1 Minute gesehen"
elif sek < 60*60:
return f"Zuletzt vor {sek // 60} Minuten gesehen"
elif sek < 60*60*24:
return f"Zuletzt vor {sek // (60*60)} Stunden gesehen"
else:
return f"Zuletzt vor {sek // (60*60*24)} Tagen gesehen"

Python MOOC - 4.3 Unit Tests TOC 140/ 145

Unit Test – ”zuletzt gesehen”
Skript test [Link] mit:
import unittest
from onlinestatus import zuletzt_gesehen
class ZuletztGesehenTest([Link]):
def test_online(self):
tatsaechlich = zuletzt_gesehen(0)
erwartet = "Online"
[Link](tatsaechlich, erwartet)
Test ausführen - Option 1: Am Ende von test [Link] :
if __name__ == "__main__": [Link]()
Test ausführen - Option 2: leichter automatisierbar
python -m unittest test_onlinestatus.py # Mac: python3
## ------------------------------------------------------
## Ran 1 test in 0.000s
## OK
Python MOOC - 4.3 Unit Tests TOC 141/ 145
Mehr Tests!
import unittest
from onlinestatus import zuletzt_gesehen
class ZuletztGesehenTest([Link]):
def test_online(self):
[Link](zuletzt_gesehen(0), "Online")
def test_eine_sekunde(self):
[Link](zuletzt_gesehen(1),
"Zuletzt vor weniger als 1 Minute gesehen")
def test_weniger_als_eine_minute(self):
[Link](zuletzt_gesehen(59),
"Zuletzt vor weniger als 1 Minute gesehen")
def test_eine_minute(self):
[Link](zuletzt_gesehen(60),
"Zuletzt vor 1 Minute gesehen")
def test_weniger_als_zwei_minuten(self):
[Link](zuletzt_gesehen(119),
"Zuletzt vor 1 Minute gesehen")
def test_zwei_minuten(self):
[Link](zuletzt_gesehen(120),
"Zuletzt vor 2 Minuten gesehen")
Python MOOC - 4.3 Unit Tests TOC 142/ 145
Testergebnis interpretieren

python -m unittest test [Link]

## F...F.
## ======================================================================
## FAIL: test eine minute (test [Link])
## ----------------------------------------------------------------------
## Traceback (most recent call last):
## File "test [Link]", line 11, in test eine minute
## [Link](zuletzt gesehen(60), "Zuletzt vor 1 Minute gesehen")
## AssertionError: ’Zuletzt vor 1 Minuten gesehen’ !=
’Zuletzt vor 1 Minute gesehen’
## - Zuletzt vor 1 Minuten gesehen
## ? -
## + Zuletzt vor 1 Minute gesehen
##
## [...]
##
## ----------------------------------------------------------------------
## Ran 6 tests in 0.001s
##
## FAILED (failures=2)

Python MOOC - 4.3 Unit Tests TOC 143/ 145

Vorteile von Tests

▶ Gesicherte Funktionsweise: Korrektheit der getesteten Einheiten

bereits während der Entwicklung prüfen
▶ Weniger Fehler: Unerwünschte Seiteneffekte früh finden
▶ Unterstützung beim Refactoring: Quellcode ohne Angst ändern
▶ Reflektierte Strukturierung: Code Design gut überlegen
▶ Zufriedenheit bei der Entwicklung: dem Ergebnis vertrauen und
manuelles Testen vermeiden
▶ Code testgetrieben entwicklen (TDD, Test-driven development):
▶ Zuerst den Test schreiben ( test [Link] )
▶ Danach die eigentliche Implementierung ( [Link] )

Kurzfristig: die Entwicklung verlangsamt sich

Langfristig: der Code wird stabiler und die Struktur verbessert

Python MOOC - 4.3 Unit Tests TOC 144/ 145

Zusammenfassung für 4.3 Unit Tests
Code systematisch prüfen:
▶ abgeschlossene Einheiten (Units) auf korrekte Funktion überprüfen
import unittest # Modul importieren
from datei import funktion # Code importieren
class FunktionsTest([Link]):
def test_rueckgabe(self): # Testfall definieren
[Link](funktion(0), "Sollwert")
if __name__ == "__main__":
[Link]()
▶ Für die Test-Klasse immer ([Link]) angeben
▶ Jede Test-Methode mit test beginnen und (self) angeben
▶ Weiterführendes Material: Beispiele unterschiedlicher Testverfahren,
Unittest-Dokumentation (English), assert-Methoden

Melde unklare Aufgaben im Forum.

Markiere die Inhalte dieser Lektion in deiner RefCard.
Python MOOC - 4.3 Unit Tests TOC 145/ 145