Aktuelle Version: Python 3.14
Interpretierte Programmiersprache
In der Standardversion cpython: kein Kompilieren zu Maschinencode, sondern zu Bytecode
Programme werden mit dem python-Programm ausgeführt
Eignet sich sehr gut zum Erlernen der Programmierung!
Viele nützliche Pakete, die das wissenschaftliche Arbeiten extrem erleichtern!

Hier soll es bis Mittwoch hingehen; Auswertung von Praktikumsversuchen:

from IPython.display import Image

Image(filename="build/muon_plot.png")

Versuch aus dem Fortgeschrittenen-Praktikum: Lebensdauer kosmischer Myonen

Grundlagen¶

Eine Programmiersprache wie Python lässt sich nicht an einem Tag lernen. Wir geben hier einen kurzen Überblick über die wichtigsten Konzepte.

Keine Angst: Zum Erstellen von Plots und für einfache Auswertungen musst du nicht viel Python können!

Alle folgenden Beispiele kann man auf der Kommandozeile ausprobieren.

Dazu zunächst die virtuelle Python Umgebung mit

mamba activate toolbox

aktiveren.

Anschließend kannst du einen python Interpreter mit

python

starten, und dort Beispiele ausprobieren.

Einfachstes Beispiel¶

print("Hello, World!")

Hello, World!

Kommentare¶

Sehr wichtig für die Leute, die mit euch arbeiten
Auch für euch selbst zwei Wochen später

Alles was in Python hinter einem # steht, wird nicht als Code betrachtet und dient als Kommentar. Längere Kommentare, streng Docstrings, werden mit drei Anführungszeichen begonnen und mit drei weiteren beendet.

"""
We start the workshop with the traditional first program.
"""
print("Hello, World!")
# This example is chosen to show the basic functionalities of python.

Hello, World!

Kommentare sollten nicht erklären, was der Code tut, sondern warum. Wie jeder andere Code, sollten Kommentare auf Englisch sein.

Auslagern in Python-Dateien¶

Python-Dateien geben wir die Endung .py
Ausführen mit python programm.py
Die Datei muss mit dem Encoding UTF-8 abgespeichert werden. (Standard in modernen Editoren / Betriebssystemen)

Exportieren wir als Beispiel unseren “Hello World!” Code in eine Datei.

Variablen¶

Man kann einem Objekt einen Namen geben, dazu kennen wir aus der Mathematik:

a = 2
b = 3

Variablennamen können auch überschrieben werden:

a = 42
b = a

a = 0
b

42

Namen verweisen auf Objekte
Mehrere Namen können auf das gleiche Objekt zeigen

Datentypen¶

Einfache Datentypen¶

Booleans¶

True und False

Logische Operatoren: and, or, not

True and False

False

True or False

True

not True

False

None oder leere Objekte verhalten sich wie False, andere wie True

"" or True

True

"Hallo" and True

True

Zahlen¶

Ganze Zahlen: 42
Kommazahlen: 3.14
Komplexe Zahlen: 3 + 2j

Rechenoperatoren:

+, -, *
** (Potenzieren: 2**3 → 8)
/ (3 / 2 → 1.5)
// (Ganzzahldivision: 3 // 2 → 1)
% (Modulo-Operation, Divisionsrest: 7 % 4 → 3)

x = 5
y = 3
x + y

8

Rechenoperationen können geklammert werden

a = 2 + 4 / 5 + 1
b = (2 + 4) / 5 + 1
c = (2 + 4) / (5 + 1)

print(a, b, c)

3.8 2.2 1.0

a = 3 + 2j
b = 1 + 1j

print(a + b, a * b, abs(b))

(4+3j) (1+5j) 1.4142135623730951

Vergleichsoperatoren geben True oder False zurück

==, !=
>, <, >=, <=

x = 5
y = 3
x < y

False

Mehrere Vergleichsoperatoren können in einem Ausdruck stehen:

a = 3.8
b = 2.2
c = 1
c < b < a

True

c < a < b

False

Kurzaufgaben 1, 2 und 3¶

Definiere die folgenden Variablen mit den angegebenen Werten

Variable $t$ , Wert: 0.5s
Variable $h_i$ , Wert: 10m
Variable $v_i$ , Wert: 0.75m/s
Variable $a_i$ , Wert: -9.81m/s²

Berechne mit den obigen Werten die Höhe $h$ , Geschwindigkeit $v$ und Beschleunigung $a$ zum Zeitpunkt $t=0.5$ s eines fallenden Objekts. Speicher die Ergebnisse in entsprechenden Variablen $h$ , $v$ , $a$ .
Prüfe, ob das Objekt bereits über einen Meter gefallen ist.

Die Lösungen für die Kurzaufgaben sind am Ende dieser Datei oder in der loesung.py in exercises-toolbox/1-python/Kurzaufgaben.

Strings¶

Stehen in ' oder ". (Für eins entscheiden)

foo = "foo"
bar = "bar"

Strings können mit + konkateniert werden:

foo + " " + bar

'foo bar'

Strings können mit * vervielfacht werden

foo * 4

'foofoofoofoo'

Strings können mit [] indiziert werden

foo[0]

'f'

Können beliebige Unicode Symbole enthalten

print("π ist genau 3, Erwin Schrödinger")

π ist genau 3, Erwin Schrödinger

None¶

Stellt das Fehlen eines Wertes dar.

Wird häufig für Standardwerte von Funktionen verwendet.

print(None)

None

Funktionen, die ‘nichts’ zurückgeben, geben None zurück:

print("test")

test

a = print("test")

test

print(a)

None

Kurzaufgaben 4¶

Nutze die print-Funktion, um die gegebenen Startwerte und die Ergebnisse der letzten Kurzaufgabe mit Überschriften zu versehen und auszugeben.

Sammlungen (Collections)¶

Speichern mehrerer Objekte

Listen¶

Veränderbar
Gedacht für mehrere Werte vom selben Typ

names = ["foo", "bar"]

Listen können mit [] indiziert werden

names[1]

'bar'

Man kann Werte an Listen anhängen:

names.append("baz")
names

['foo', 'bar', 'baz']

Negative Indizes (beginnend mit -1), indizieren die Liste rückwärts

names[-1]

'baz'

Man kann auch Teillisten indizieren.
names[Anfang:Ende] liefert eine Teilliste mit den Werten von names[Anfang] bis names[Ende-1]:

names[1:3]

['bar', 'baz']

Listen werden mit + zusammengeführt:

names + ["thing"]

['foo', 'bar', 'baz', 'thing']

Listen können mit * vervielfacht werden:

names * 3

['foo', 'bar', 'baz', 'foo', 'bar', 'baz', 'foo', 'bar', 'baz']

Die Liste kann auch erweitert werden:

names.extend(["quux", "quem"])
names

['foo', 'bar', 'baz', 'quux', 'quem']

Listen sind veränderbar, man kann ihnen Werte zuweisen:

names[1] = "new"
names

['foo', 'new', 'baz', 'quux', 'quem']

Mit in wird überprüft, ob ein Wert in der Liste ist:

weekdays = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
"Mo" in weekdays

True

Tupel¶

Gedacht für Werte mit unterschiedlichen Typen
Werden an allen möglichen Stellen von python erzeugt

tup = (5, 3)
tup

(5, 3)

Können wahlweise auch ohne Klammern geschrieben werden (wenn es eindeutig ist).

tup = 5, 3
tup

(5, 3)

a = 5
b = 3
a, b = b, a

print("a =", a)
print("b =", b)

a = 3
b = 5

tup[0]

5

Einträge nach Erzeugung unveränderbar:

tup[1] = 7

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[42], line 1
----> 1 tup[1] = 7

TypeError: 'tuple' object does not support item assignment

Kurzaufgaben 5¶

Definiere eine Liste mit Namen T, die die 3 Werte 0.5, 1 und 1.5 enthält. Definiere drei leere Listen mit den Namen H, V und A. Berechne dann für jede der drei Zeiten wie zuvor die Höhe, Geschwindigkeit und Strecke, jedoch indem du
```
a) die Werte aus der Liste T verwendest (T[i] für das entsprechende i),
b) die Ergebnisse an die zugehörige Liste anhängst.
```
Gib die Listen H, V, A mit der print-Funktion aus.

Dictionaries¶

numbers = {"one": 1, "two": 2, "three": 3}

numbers["two"]

2

Dictionaries sind extrem hilfreich, zum Beispiel um die verschiedene Datensätze der gleichen Messung zusammenzufassen. So wird es einfacher dieselbe Analyse auf die einzelnen Datensätze anzuwenden.

data = {"Cu": [1.1, 1.2, 1.3, 1.4], "Fe": [0.7, 0.8, 0.9, 1.0]}
data["Cu"]

[1.1, 1.2, 1.3, 1.4]

Leere Dictionaries werden mit der Funktion dict()erstellt.

data = dict()
data

{}

data["Fe"] = [1.1, 1.2, 1.3, 1.4]
data

{'Fe': [1.1, 1.2, 1.3, 1.4]}

data["Cu"] = [0.7, 0.8, 0.9, 1.0]
data

{'Fe': [1.1, 1.2, 1.3, 1.4], 'Cu': [0.7, 0.8, 0.9, 1.0]}

data["Au"] = [0.2, 0.3, 0.1, 0.5]
data

{'Fe': [1.1, 1.2, 1.3, 1.4],
 'Cu': [0.7, 0.8, 0.9, 1.0],
 'Au': [0.2, 0.3, 0.1, 0.5]}

Kurzaufgaben 6 und 7¶

Speichere die zuvor erstellten Listen in einem Dictionary mit dem Namen data und den keys t, h, v und a. Gib das Dictionary mit der print-Funktion aus.
Greife auf die folgenden Werte im Dictionary zu:

der zweite Wert von t
der erste Wert von v
der letzte Wert von h

Kontrollstrukturen¶

Die Zeilen eines Python-Programms werden nacheinander ausgeführt.

Sogennante Kontrollstrukturen erlauben es, den Ablauf zu steuern.

`if` / `elif` / `else`¶

a = 3

if a == 1:
    # muss eingerückt werden, 4 spaces:
    print("foo")
elif a == 2:
    print("bar")
else:
    print("baz")

baz

`while`¶

Wiederholen, solange eine Bedingung erfüllt ist.

i = 0
while i < 5:
    print(i)
    i += 1

# there has to be a better way!

`for`¶

Wiederholen für jedes Elements (z.B. einer Liste)

data = [10, 42, -1]

for x in data:
    # Wir können auf das jetzige Element als "x" zugreifen
    print(2 * x)

20
84
-2

klassische for-Schleife mit range:

for i in range(5):
    print(i)

for i in range(2, 5):
    print(i)

2
3
4

for i in range(2, 10, 2):
    print(i)

for i in range(10, 3, -1):
    print(i)

weekdays = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
for day in weekdays:
    print("Heute ist", day)

Heute ist Mo
Heute ist Di
Heute ist Mi
Heute ist Do
Heute ist Fr
Heute ist Sa
Heute ist So

Zwei sehr nützliche Funktionen sind enumerate und zip

for i, day in enumerate(weekdays):
    print(day, " ist der ", i + 1, ". Tag der Woche", sep="")

Mo ist der 1. Tag der Woche
Di ist der 2. Tag der Woche
Mi ist der 3. Tag der Woche
Do ist der 4. Tag der Woche
Fr ist der 5. Tag der Woche
Sa ist der 6. Tag der Woche
So ist der 7. Tag der Woche

Was enumerate() macht:

list(enumerate(weekdays))

[(0, 'Mo'), (1, 'Di'), (2, 'Mi'), (3, 'Do'), (4, 'Fr'), (5, 'Sa'), (6, 'So')]

voltages = [1, 3, 5]
currents = [1, 5, 1]

for voltage, current in zip(voltages, currents):
    print("R =", voltage / current, "Ω")

R = 1.0 Ω
R = 0.6 Ω
R = 5.0 Ω

Was zip() macht:

list(zip(voltages, currents))

[(1, 1), (3, 5), (5, 1)]

Iterieren über die Einträge von dict

translations = {
    "foot": "Fuß",
    "ball": "Ball",
    "goal": "Tor",
}

for e, g in translations.items():
    print(e, g)

foot Fuß
ball Ball
goal Tor

Übungen 1, 2, und 3 können jetzt bearbeitet werden.

Funktionen¶

Mit Funktionen lässt sich Code leicht wiederverwenden. Eine Funktion nimmt Parameter, verarbeitet sie und gibt Ergebnisse zurück.

print("Hello!")

Hello!

len([1, 2, 3, 4, 5])

5

Viele Funktionen haben mehrere Parameter, einige können sogar beliebig viele haben:

print(1, 2, 3, 4, 5)

1 2 3 4 5

Viele Funktionen haben optionale Parameter mit eigenem Namen, sogenannte “keyword arguments”:

print(1, 2, 3, 4, 5, sep=", ")

1, 2, 3, 4, 5

Objekte haben auch Funktionen (diese nennt man Methoden):

s = "test"
s.upper()

'TEST'

"foo bar baz".split()

['foo', 'bar', 'baz']

Im python-Terminal kann man wie folgt auf die Dokumentation einer Funktion zugreifen:

help(print)

Help on built-in function print in module builtins:

print(*args, sep=' ', end='\n', file=None, flush=False)
    Prints the values to a stream, or to sys.stdout by default.

    sep
      string inserted between values, default a space.
    end
      string appended after the last value, default a newline.
    file
      a file-like object (stream); defaults to the current sys.stdout.
    flush
      whether to forcibly flush the stream.

Ansonsten findet man ausführliche Erklärungen in der offiziellen Dokumentation.

Eigene Funktionen definieren mit `def`¶

Um mehrfach benötigten Code einfacher zu nutzen, können Funktionen definiert werden.

Vorteile:

Weniger Code
Änderungen nur an einer Stelle notwendig

def add(x, y):
    z = x + y
    return z


add(2, 2)

4

Mit dem return Statement wird die Funktion beendet und Ergebnisse zurückgeben.

Es können auch mehrere Werte zurückgeben werden:

def divide(x, y):
    return x // y, x % y


n, rest = divide(5, 3)
n, rest

(1, 2)

Funktionen können sich selbst aufrufen (Rekursion)

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)


factorial(4)

24

Kurzaufgaben 8 und 9¶

Definiere jeweils eine Funktion für die Berechnung von h, v und a zu einem beliebigen Zeitpunkt t.
Erstelle eine neue Liste T mit den Werten 0,25, 0,5, 0,75, 1,0, 1,25 und 1,5. Und erstelle das Dictionary data erneut für alle Zeitpunkte in T. Verwende dafür die in 8. erstellten Funktionen.

Zusatz: Du kannst auch die Listen H, V und A neu erstellen und dafür eine Schleife verwenden.

Gib data mit der print-Funktion aus.

Module und `import`¶

In Python kann man Code in einzelne Module portionieren. Es stehen bereits unglaublich viele Module für Python zur Verfügung. Und gerade für das wissenschaftliche Arbeiten ist eigentlich alles da, was gebraucht wird und noch viel mehr.

Wird etwas aus einem anderen Modul gebraucht, importiert man es.

Zahlreiche Module sind Teil jeder Python Installation, die sogenannte “standard library”: https://docs.python.org/3/library/

Weitere Module hast du in deiner toolbox Umgebung mit Mamba installiert.

import os

os.listdir(".")

['.gitignore',
 'README.md',
 'data',
 'header-matplotlib.tex',
 'images',
 'matplotlibrc_muon',
 'exp.txt',
 'exp_polyfit.ipynb',
 'build',
 'plot.pdf',
 'plot_1.pdf',
 'plot_2.pdf',
 'test.txt',
 'Makefile',
 'matplotlib.ipynb',
 'muon_plot.py',
 'numeric-python.ipynb',
 'python.ipynb',
 'scientific-python.ipynb',
 'uncertainties.ipynb',
 '.ipynb_checkpoints']

Für das Importieren einzelner Funktionen gibt es den Befehl:

from time import sleep

print("hello")
sleep(1)
print("world")

hello
world

Den Modulen können mit as neue Namen gegeben werden. Viele Module haben jedoch Konventionen für den Kurznamen, die du verwenden solltest.

import numpy as np

np.sum([1, 2])  # siehe numpy Kurs

np.int64(3)

Auslagern in Python-Dateien Part II¶

Erinnerung an Part I

Python-Dateien geben wir die Endung .py
Ausführen mit python programm.py
Die Datei muss mit dem Encoding UTF-8 abgespeichert werden. (Standard in modernen Editoren / Betriebssystemen)

Eigene Module

Einzelne Python-Dateien (Endung .py) kann man als Module benutzen.
Liegt eine Datei test.py im selben Ordner, so kann der Inhalt mit import test in einer weiteren Datei verwendet werden.

Es folgt ein fertiges Python-Programm.

Speicher es als primes.py ab und starte es aus dem Terminal mit python primes.py.

def primes(max_num):
    # Only primes smaller than max_num are calculated
    is_prime = max_num * [True]
    is_prime[0] = False
    is_prime[1] = False

    primes = []

    # Sieve of Erathosthenes:
    for i in range(2, max_num):
        if is_prime[i]:
            for j in range(2 * i, max_num, i):
                # Multiples are not primes
                is_prime[j] = False
            primes.append(i)

    return primes


print(primes(100))

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

Übung 4, 5 und 6 können bearbeitet werden.

Formatieren von Strings¶

f-strings¶

Oft will man Werte oder andere Strings in einen String einsetzen.

Seit der Python Version 3.6 gibt es sogenannte f-strings (formatted strings) für String-Formatierung:

U = 42
R = 7

print(f"Spannung U = {U} V, R = {R} Ω, I = {U / R} A")

Spannung U = 42 V, R = 7 Ω, I = 6.0 A

Der Ausdruck in den {}-Markierungen wird ausgewertet und das Ergebnis anstelle der geschweiften Klammern gesetzt.
Variablen ersetzt.

f-strings haben viele fortgeschrittene Funktionen. Beispielsweise kann die gewünschte Genauigkeit für floats angeben werden:

result = 3.2291421

print(f"Das Ergebnis ist {result:.2f}")

Das Ergebnis ist 3.23

Alle Formateinstellungen werden nach einem Doppelpunkt angegeben.
Für die Genauigkeit sieht die Angabe allgemein so aus: :.Nf
N ist dabei die gewünschte Anzahl an Nachkommastellen.

Sonderzeichen¶

Mit \ kann man in Strings besondere Anweisungen setzen:

'\n' -> Zeilenumbruch
'\t' -> Tab
'\\' -> normales '\'

Wenn viele '\' geschrieben werden müssen (z.B. in LaTeX-Code), lohnt es sich diese Funktion mit dem Präfix r auszuschalten:

print(r"\Huge\texttt{Python}")

\Huge\texttt{Python}

Will man { oder } im Text stehen haben (für LaTeX benötigt) geht das mit doppelten {{ oder }}.

LaTeX sieht dann leider so aus:

energy = 1.23456
print(rf"\qty{{{energy:.4f}}}{{\kilo\joule}}")

\qty{1.2346}{\kilo\joule}

Nur zur Demonstration einmal mit mehr Lücken (funktioniert aufgrund der Leerzeichen so nicht in LaTeX!):

print(rf"\qty {{ {energy:.4f} }} {{ \kilo\joule }}")

\qty { 1.2346 } { \kilo\joule }

Kurzaufgaben 10¶

Nutze eine Schleife über das Dictionary data, um die Daten in Tabellenform auszugeben.

t  0.25  0.50  0.75  1.00  1.25  1.50
h  9.88  9.15  7.80  5.84  3.27  0.09
v  -2.27  -4.53  -6.79  -9.06  -11.33  -13.59
a  -9.81  -9.81  -9.81  -9.81  -9.81  -9.81

Jede Zeile der Tabelle kann dabei durch Verwendung eines f-Strings formatiert werden.

Comprehensions¶

Sind nützlich, um Listen oder Dictionaries umzuwandeln oder zu erzeugen:

# Ursprüngliche Liste
list(range(5))

[0, 1, 2, 3, 4]

# List-Comprehension
[2 * x for x in range(5)]

[0, 2, 4, 6, 8]

# List-Comprehension mit Bedingung
[2 * x for x in range(5) if x % 2 == 0]

[0, 4, 8]

# Ursprüngliche Liste
weekdays = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]

# Dict-Comprehension
{num + 1: name for num, name in enumerate(weekdays)}

{1: 'Mo', 2: 'Di', 3: 'Mi', 4: 'Do', 5: 'Fr', 6: 'Sa', 7: 'So'}

# Ursprüngliche Listen
print(list(range(3)))
print(list(range(4)))

[0, 1, 2]
[0, 1, 2, 3]

# List-Comprehension mit verschachtelten Schleifen
[x + y for y in range(3) for x in range(4)]

[0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5]

# List-Comprehension mit verschachtelten Schleifen und Bedingung
[x + y for y in range(3) for x in range(4) if x % 2 == 0]

[0, 2, 1, 3, 2, 4]

Übung 7 kann jetzt bearbeitet werden.

Häufig auftretende Fehler¶

Einige Fehler werden zu Anfang sehr häufig gemacht (und immer mal wieder).
Wenn man die Fehlermeldungen richtig zu lesen weiß, kann einem das viel Arbeit/Frust ersparen.
Das Wichtigste ist: Lies die Fehlermeldung und versuche sie zu verstehen!

Gerade am Anfang beliebt: `IndentationError`:¶

Die Fehlermeldung gibt die Zeile an, in der der Fehler auftritt (hier: line 8)
und den Grund für den Fehler, häufig mit Erklärung (hier: IndentationError: expected an indented block after 'if' statement on line 6).

a = 5
b = 7
c = 9

if a <= b:
    if c >= b:
    # Zeile 8 müsste in dem if-Block eingerückt werden
    print("a <= b und c >= b")
    else:
        print("a <= b und b > c")
else:
    print("a > b")

  Cell In[90], line 8
    print("a <= b und c >= b")
    ^
IndentationError: expected an indented block after 'if' statement on line 6

Allgemeiner Syntax-Fehler: `SyntaxError`¶

Zeile, in der der Fehler auftritt: line 6
Grund für den Fehler: SyntaxError: expected ':'
Hier sogar mit Hinweis auf das fehlerhafte/fehlende Zeichen.

a = 5
b = 7
c = 9

# In Zeile 6 fehlte der Doppelpunkt ':' nach der Bedingung, um den If-Block einzuleiten
if a <= b
    if c >= b:
        print("a <= b und c >= b")
    else:
        print("a <= b und b > c")
else:
    print("a > b")

  Cell In[91], line 6
    if a <= b
             ^
SyntaxError: expected ':'

Klammerfehler¶

Zeile, in der der Fehler auftritt: line 10
Grund für den Fehler: SyntaxError: '(' was never closed
Hier sogar mit Hinweis auf die Klammer, die keinen Partner hat.

a = 5
b = 7
c = 9


if a <= b:
    if c >= b:
        # In Zeile 10 fehlt eine Klammer, zum Vergleich:
#       d = ((a + b) / (a + c))/((a + b) / (a + c)) 
        d = ((a + b) / (a + c)/((a + b) / (a + c))
        print("a <= b und c >= b")
    else:
        print("a <= b und b > c")
else:
    print("a > b")

  Cell In[92], line 10
    d = ((a + b) / (a + c)/((a + b) / (a + c))
        ^
SyntaxError: '(' was never closed

Auch sehr einfach auszulösen: `NameError`:¶

Zeile in der der Fehler auftritt: ----> 8 if a <= n:
Grund für den Fehler: NameError: name 'n' is not defined Wir können keine Variable verwenden, die nicht existiert.

del n  # Please ignore me, I'm just setting the stage for the example
a = 5
b = 7
c = 9

# Beim Schreiben des Codes vertippt (n anstelle von b),
# sodass a <= n statt a <= b ausgewertet wird, n ist jedoch nicht definiert
if a <= n:
    if c >= b:
        print("a <= b und c >= b")
    else:
        print("a <= b und b > c")
else:
    print("a > b")

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[93], line 8
      4 c = 9
      6 # Beim Schreiben des Codes vertippt (n anstelle von b),
      7 # sodass a <= n statt a <= b ausgewertet wird, n ist jedoch nicht definiert
----> 8 if a <= n:
      9     if c >= b:
     10         print("a <= b und c >= b")

NameError: name 'n' is not defined

Fehler bei Zugriffen auf Listen: `IndexError`¶

Zeile in der der Fehler auftritt: ----> 4 names[4]
Grund für den Fehler: IndexError: list index out of range

names = ["Anna", "Jan", "Marie", "Tim"]
# Die Liste hat vier Einträge, da der erste Index aber 0 ist ist der letzte Index 3
# der Index 4 der in Zeile 4 abgerufen wird überschreitet diesen Bereich
names[4]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[94], line 4
      1 names = ["Anna", "Jan", "Marie", "Tim"]
      2 # Die Liste hat vier Einträge, da der erste Index aber 0 ist ist der letzte Index 3
      3 # der Index 4 der in Zeile 4 abgerufen wird überschreitet diesen Bereich
----> 4 names[4]

IndexError: list index out of range

Fehler bei Zugriffen auf Dictionaries: `KeyError`¶

Zeile in der der Fehler auftritt: ----> 4 numbers["five"]
Grund für den Fehler: KeyError: 'five'

numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
# Analog zum Beispiel mit der Listen Index
# Der key "five" ist nicht in dem Dictionary vorhanden
numbers["five"]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[95], line 4
      1 numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
      2 # Analog zum Beispiel mit der Listen Index
      3 # Der key "five" ist nicht in dem Dictionary vorhanden
----> 4 numbers["five"]

KeyError: 'five'

Komplexer Fehler mit Traceback:¶

Wenn an einem Fehler mehrere Funktionen beteiligt sind, gibt die Fehlermeldung einen Traceback aus. Dieser Fall ist eher die Regel, vor allem, wenn Module verwendet werden. Der Traceback zeigt die Reihenfolge aller Funktionsaufrufe, die am Ende zu dem Fehler geführt haben, mit dem letzten Aufruf ganz unten (most recent call last).

Zeilen, die zum Auftreten des Fehlers führen:
Funktionsaufruf in Zeile 13:
---> 16 add_one_to_inverse_difference(x,y)
Ergebnis des Funktionsaufrufs ist das return in Zeile 6 mit neuem Funktionsaufruf:
----> 6 return 1 + inverse_difference(a, b)
Ergebnis des 2. Funktionsaufrufs ist das return in Zeile 2:
----> 2 return 1/(a - b)
Hier tritt der Fehler auf, da durch Null geteilt wird, wenn a und b gleich sind!

Grund für den Fehler: ZeroDivisionError: division by zero

def inverse_difference(a, b):
    return 1 / (a - b)


def add_one_to_inverse_difference(a, b):
    return 1 + inverse_difference(a, b)


def add_2_to_inverse_difference(a, b):
    return add_one_to_inverse_difference(a, b) + 2


x = 2
y = 2

add_one_to_inverse_difference(x, y)

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[96], line 16
     13 x = 2
     14 y = 2
---> 16 add_one_to_inverse_difference(x, y)

Cell In[96], line 6, in add_one_to_inverse_difference(a, b)
      5 def add_one_to_inverse_difference(a, b):
----> 6     return 1 + inverse_difference(a, b)

Cell In[96], line 2, in inverse_difference(a, b)
      1 def inverse_difference(a, b):
----> 2     return 1 / (a - b)

ZeroDivisionError: division by zero

Debugging leicht gemacht¶

Es kann vorkommen, dass man mal überhaupt nicht weiß, warum etwas nicht funktioniert.

In diesem Fall sollte man zunächst mal Ruhe bewahren und sich dann auf systematische Fehlersuche begeben.
Ein einfacher Ansatz ist das print()-debugging.

Kleiner Trick, um Schuhgröße und Alter einer weiteren Person zu berechnen. Die zweite Person muss folgende Anweisungen befolgen:

1. Multipliziere deine Schuhgröße mit 5         
2. Addiere 50 zum Ergebnis                      
3. Multipliziere das Ergebnis mit 20            
4. Addiere 1020 zum Ergebnis                    
5. Ziehe dein Geburtsjahr vom Ergebnis ab
6. Nenne das Ergebnis

def shoesize_and_age(shoesize, birth_year):
    step_1 = shoesize * 5
    step_2 = step_1 + 50
    step_3 = step_2 * 20
    step_4 = step_3 + 1020
    step_5 = step_4 - birth_year

    return step_5

Beispiel:¶

Mit der Schuhgröße 49 und dem Geburtsjahr 1998, kriege ich die Zahl 4922 raus.
Ich habe (wie erwähnt, die Schuhgröße 45) und 98 geboren.
Wie funktioniert dieser Trick?!

shoesize_and_age(49, 1998)

4922

Die print()-Debugguing Methode:

def shoesize_and_age(shoesize, birth_year):
    print(f"{shoesize = }")
    step_1 = shoesize * 5
    print(f"{step_1 = }")
    step_2 = step_1 + 50
    print(f"{step_2 = }")
    step_3 = step_2 * 20
    print(f"{step_3 = }")
    step_4 = step_3 + 1020
    print(f"{step_4 =}")
    step_5 = step_4 - birth_year
    print(f"{step_5 = }")

    return step_5

shoesize_and_age(49, 1998)

shoesize = 49
step_1 = 245
step_2 = 295
step_3 = 5900
step_4 =6920
step_5 = 4922

4922

Lösungen für die Kurzaufgaben¶

# 4.
print("Start...")
print("...höhe")
print(h_i)
print("...geschwindigkeit")
print(v_i)
print("...beschleunigung")
print(a_i)

print("Nach der Zeit t")
print(t)
print("Höhe")
print(h)
print("Geschwindigkeit")
print(v)
print("Beschleunigung")
print(a)

#  5.
T = [0.5, 1, 1.5]
H = []
V = []
A = []


H.append(h_i + v_i * T[0] + 1/2 * a_i * T[0]**2)
H.append(h_i + v_i * T[1] + 1/2 * a_i * T[1]**2)
H.append(h_i + v_i * T[2] + 1/2 * a_i * T[2]**2)

V.append(v_i * T[0] +  a_i * T[0])
V.append(v_i * T[1] +  a_i * T[1])
V.append(v_i * T[2] +  a_i * T[2])

A.append(a_i)
A.append(a_i)
A.append(a_i)

print(H)
print(V)
print(A)

# 8.
def h(t):
  return h_i + v_i * t + 1/2 * a_i * t**2


def v(t):
  return v_i * t + a_i * t


def a(t):
  return a_i


# 9.

T = [0.25, 0.5, 0.75, 1.0, 1.25, 1.5]

# ohne Schleife
data = {"t":T,
 "h": [h(T[0]), h(T[1]), h(T[2]), h(T[3]), h(T[4]), h(T[5])],
 "v": [v(T[0]), v(T[1]), v(T[2]), v(T[3]), v(T[4]), v(T[5])],
 "a": [a(T[0]), a(T[1]), a(T[2]), a(T[3]), a(T[4]), a(T[5])]}

print(data)


# mit Schleife
H = []
V = []
A = []

for t in T:
  H.append(h(t))
  V.append(v(t))
  A.append(a(t))


data = {"t":T, "h": H, "v": V, "a": A}
print(data)

for k,v in data.items():
  print(f"{k}  {v[0]:.2f}  {v[1]:.2f}  {v[2]:.2f}  {v[3]:.2f}  {v[4]:.2f}  {v[5]:.2f}")

# Am Dezimaltrennzeichen ausgerichtet

for k,v in data.items():
  print(f"{k}  {v[0]:6.2f}  {v[1]:6.2f}  {v[2]:6.2f}  {v[3]:6.2f}  {v[4]:6.2f}  {v[5]:6.2f}")

# Noch eine Schleife (List-Comprehension) mehr, erübrigt die Wiederholungen

for key, values in data.items():
  formatted_values = " ".join([f"{v:6.2f}" for v in values])
  print(f"{key}  {formatted_values}")

Grundlagen

Grundlagen¶

Einfachstes Beispiel¶

Kommentare¶

Auslagern in Python-Dateien¶

Variablen¶

Datentypen¶

Einfache Datentypen¶

Booleans¶

Zahlen¶

Kurzaufgaben 1, 2 und 3¶

Strings¶

None¶

Kurzaufgaben 4¶

Sammlungen (Collections)¶

Listen¶

Tupel¶

Kurzaufgaben 5¶

Dictionaries¶

Kurzaufgaben 6 und 7¶

Kontrollstrukturen¶

if / elif / else¶

while¶

for¶

Funktionen¶

Eigene Funktionen definieren mit def¶

Kurzaufgaben 8 und 9¶

Module und import¶

Auslagern in Python-Dateien Part II¶

Formatieren von Strings¶

f-strings¶

Sonderzeichen¶

Kurzaufgaben 10¶

Comprehensions¶

Häufig auftretende Fehler¶

Gerade am Anfang beliebt: IndentationError:¶

Allgemeiner Syntax-Fehler: SyntaxError¶

Klammerfehler¶

Auch sehr einfach auszulösen: NameError:¶

Fehler bei Zugriffen auf Listen: IndexError¶

Fehler bei Zugriffen auf Dictionaries: KeyError¶

Komplexer Fehler mit Traceback:¶

Debugging leicht gemacht¶

Beispiel:¶

Lösungen für die Kurzaufgaben¶

`if` / `elif` / `else`¶

`while`¶

`for`¶

Eigene Funktionen definieren mit `def`¶

Module und `import`¶

Gerade am Anfang beliebt: `IndentationError`:¶

Allgemeiner Syntax-Fehler: `SyntaxError`¶

Auch sehr einfach auszulösen: `NameError`:¶

Fehler bei Zugriffen auf Listen: `IndexError`¶

Fehler bei Zugriffen auf Dictionaries: `KeyError`¶