Skip to content
Snippets Groups Projects
Commit ad7bc970 authored by schwabmi's avatar schwabmi
Browse files

exchanged exkurse -> weihnachtsbaum

parent e50f551a
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
notebooks/seminar05.ipynb
+ 66
− 32
View file @ ad7bc970
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
# Seminar Problemorientierte Programmierung # Seminar Problemorientierte Programmierung
## 5 Verzweigungen und Rekursion ## 5 Verzweigungen und Rekursion
Das erste Thema dieses Kapitels ist die `if`-Anweisung, die unterschiedlichen Code ausführt, je nach Zustand des Programms. Im zweiten Teil lernen Sie die `Rekursion` kennen. Das erste Thema dieses Kapitels ist die `if`-Anweisung, die unterschiedlichen Code ausführt, je nach Zustand des Programms. Im zweiten Teil lernen Sie die `Rekursion` kennen.
(Buch: http://greenteapress.com/thinkpython2/html/thinkpython2006.html) (Buch: http://greenteapress.com/thinkpython2/html/thinkpython2006.html)
## Exkurs: Was mir an Python gefällt ## Exkurs: Was mir an Python gefällt
In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen. Wir wünschen Ihnen ein frohes Fest und einen guten Rutsch ins neue Jahr.
Mit den Operatoren aus diesem Kapitel können wir ganz leicht das Verfahren zur Umwandlung einer Dezimalzahl in ihre Binärdarstellung implementieren:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
# Umwandlung einer positiven, ganzen Dezimalzahl in Binärdarstellung (als Zeichenkette) """
def dez_zu_bin(n): Quelle: https://teampython.wordpress.com/2015/12/12/print-a-christmas-tree/
ergebnis = "" Python 3 version by antiloquax (2015), based on code from datamungeblog.com.
while n > 0: """
ergebnis = str(n % 2) + ergebnis
n = n // 2 from random import choice
return ergebnis from random import random
print(dez_zu_bin(42)) # If you change this, use an odd number.
size = 21
# Und weil wir heute beim Thema Rekursion sind ...
def dez_zu_bin_rekursiv(n): # Probability that a character will be green.
if n == 0: prob_gr = 0.6
return "" # Colour codes.
return dez_zu_bin_rekursiv(n // 2) + str(n % 2) colours = [31, 33, 34, 35, 36, 37]
# Characters to use for decorations. Experiment with these.
print(dez_zu_bin_rekursiv(42)) # The chr(169) and chr(174) characters may not work in all terminals
# (extended ASCII, c and r in a circle).
decs = ['@', '&', '*', chr(169), chr(174)]
# Format string for printing blinking characters.
blink_col = "\033[5;{0}m{1}\033[0m"
# String to print a green octothorpe ('#').
leaf = "\033[32m#\033[0m"
# Width of the tree, will grow by 2 each time.
width = 1
# Initialise the tree string, with a star at the top.
tree = "\n{}*\n".format(' ' * (size))
""" Main Loop starts now."""
""" We can't use the normal "format" centering approach:
("{:^nn}".format(string) where "nn" is the width of the line),
with these ansi codes. This is because Python sees the strings as being
more than one character long (15 & 10 for baubles and leaves)."""
# Loop from (size - 1) down to 0, using the counter as the padding size.
for pad in range(size - 1, -1, -1):
# Increase the width of the tree by 2.
width += 2
# Put the characters for the line in "temp".
temp = ""
for j in range(width):
# Make some leaves.
if random() < prob_gr:
temp += leaf
# And also some baubles.
else:
temp += blink_col.format(choice(colours), choice(decs))
# Add that string to the line, with padding.
tree += "{0}{1}\n".format(' ' * pad, temp)
# Add a "trunk" of 2 lines and return.
print(tree + "{0}{1}\n".format(' ' * (size - 1), "000") * 2)
print("\x46\x72\x6f\x68\x65\x20\x46\x65\x73\x74\x74\x61\x67\x65\x21")
```
# Warum eigentlich auf ein Zahlensystem festlegen? %% Cell type:code id: tags:
def dez_zu_allem(n, s):
if n == 0:
return ""
return dez_zu_allem(n // len(s), s) + s[n % len(s)]
print(dez_zu_allem(42, "01")) ```
print(dez_zu_allem(42, "0123456789"))
print(dez_zu_allem(42, "01234567"))
print(dez_zu_allem(42, "0123456789ABCDEF"))
print(dez_zu_allem(42, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.1 Ganzzahldivision und Restberechnung ### 5.1 Ganzzahldivision und Restberechnung
Der Operator `//` für die **Ganzzahldivision** teilt zwei ganze Zahlen und rundet das Ergebnis zu einer ganzen Zahl ab. Der Operator `//` für die **Ganzzahldivision** teilt zwei ganze Zahlen und rundet das Ergebnis zu einer ganzen Zahl ab.
Angenommen, wir wollen wissen, wie lang ein Film über 105 Minuten in Stunden dauert. Bei der üblichen Division erhalten wir eine Gleitkommazahl: Angenommen, wir wollen wissen, wie lang ein Film über 105 Minuten in Stunden dauert. Bei der üblichen Division erhalten wir eine Gleitkommazahl:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
minuten = 105 minuten = 105
minuten/60 minuten/60
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Aber normalerweise schreiben wir Stundenangaben nicht mit Dezimalpunkt. Mit der Ganzzahldivision können wir die Stunden als ganze Zahl berechnen, wobei abgerundet wird: Aber normalerweise schreiben wir Stundenangaben nicht mit Dezimalpunkt. Mit der Ganzzahldivision können wir die Stunden als ganze Zahl berechnen, wobei abgerundet wird:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
minuten = 105 minuten = 105
stunden = minuten // 60 stunden = minuten // 60
print(stunden) print(stunden)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Um den Rest der Division zu berechnen, könnten wir eine Stunde in Minuten abziehen: Um den Rest der Division zu berechnen, könnten wir eine Stunde in Minuten abziehen:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
rest = minuten - stunden * 60 rest = minuten - stunden * 60
print(rest) print(rest)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Alternativ können wir auch den Operator `%` zur **Restberechnung** (siehe **modulo**) verwenden. Dieser teilt zwei ganze Zahlen und gibt uns den Rest zurück: Alternativ können wir auch den Operator `%` zur **Restberechnung** (siehe **modulo**) verwenden. Dieser teilt zwei ganze Zahlen und gibt uns den Rest zurück:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
rest = minuten % 60 rest = minuten % 60
print(rest) print(rest)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Dieser Operator ist nützlicher, als es auf den ersten Blick erscheinen mag. Beispielsweise können wir damit leicht prüfen, ob eine Zahl durch eine andere Zahl teilbar ist - wenn `x % y` gleich Null ist, dann ist `x` durch `y` teilbar. Dieser Operator ist nützlicher, als es auf den ersten Blick erscheinen mag. Beispielsweise können wir damit leicht prüfen, ob eine Zahl durch eine andere Zahl teilbar ist - wenn `x % y` gleich Null ist, dann ist `x` durch `y` teilbar.
Außerdem können wir damit die am weitesten rechts liegende Ziffer einer Zahl extrahieren. Beispielsweise ergibt `x % 10` die am weitesten rechts liegende Ziffer von `x`, also die Einerstelle (in der Basis 10). Analog liefert uns `x % 100` die letzten beiden Ziffern: Außerdem können wir damit die am weitesten rechts liegende Ziffer einer Zahl extrahieren. Beispielsweise ergibt `x % 10` die am weitesten rechts liegende Ziffer von `x`, also die Einerstelle (in der Basis 10). Analog liefert uns `x % 100` die letzten beiden Ziffern:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
print(4711 % 100) print(4711 % 100)
print(8 % 7) print(8 % 7)
print (15 % 7) print (15 % 7)
rest = 15 % 7 rest = 15 % 7
print("Der Rest von 15 / 7 ist", rest) print("Der Rest von 15 / 7 ist", rest)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Berechnen Sie, wie viele Stunden und Minuten 1270 Minuten ergeben: Berechnen Sie, wie viele Stunden und Minuten 1270 Minuten ergeben:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
zeit = 1270 zeit = 1270
# Fügen Sie hier den Code ein, um die Anzahl Stunden und Minuten zu berechnen # Fügen Sie hier den Code ein, um die Anzahl Stunden und Minuten zu berechnen
print(zeit, "Minuten entsprechen", stunden, "Stunden und", minuten, "Minuten") print(zeit, "Minuten entsprechen", stunden, "Stunden und", minuten, "Minuten")
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
```1270 Minuten entsprechen 21 Stunden und 10 Minuten``` ist die richtige Ausgabe ```1270 Minuten entsprechen 21 Stunden und 10 Minuten``` ist die richtige Ausgabe
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.2 Boolesche Ausdrücke ### 5.2 Boolesche Ausdrücke
Ein **Boolescher Ausdruck** ist ein Ausdruck, der entweder wahr oder falsch ist. Die folgenden Beispiele nutzen den `==`-Operator, der zwei Operanden vergleicht und `True` zurückliefert, falls Sie gleich sind, und ansonsten `False`: Ein **Boolescher Ausdruck** ist ein Ausdruck, der entweder wahr oder falsch ist. Die folgenden Beispiele nutzen den `==`-Operator, der zwei Operanden vergleicht und `True` zurückliefert, falls Sie gleich sind, und ansonsten `False`:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
5 == 5 5 == 5
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
5 == 6 5 == 6
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
`True` und `False` sind zwei besondere Werte, die zum Datentyp `bool` gehören; sie sind keine Zeichenketten! `True` und `False` sind zwei besondere Werte, die zum Datentyp `bool` gehören; sie sind keine Zeichenketten!
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
type(True) type(True)
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
type(False) type(False)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Der `==`-Operator ist einer der sogenannten **relationalen Operatoren**; die anderen sind: Der `==`-Operator ist einer der sogenannten **relationalen Operatoren**; die anderen sind:
```python ```python
x != y # x ist ungleich y x != y # x ist ungleich y
x > y # x ist größer als y x > y # x ist größer als y
x < y # x ist kleiner als y x < y # x ist kleiner als y
x >= y # x ist größer oder gleich y x >= y # x ist größer oder gleich y
x <= y # x ist kleiner oder gleich y x <= y # x ist kleiner oder gleich y
``` ```
Auch wenn Ihnen diese Symbole wahrscheinlich bekannt vorkommen, so sind sie doch anders als ihre mathematischen Äquivalente. **Ein üblicher Fehler ist, das einfache Gleichheitszeichen (`=`) statt des doppelten Gleichheitszeichens (`==`) zu verwenden.** Wir merken uns: `=` ist der Zuweisungsoperator und `==` ist ein relationaler Operator. Die Operatoren `=<` und `=>` gibt es nicht. Auch wenn Ihnen diese Symbole wahrscheinlich bekannt vorkommen, so sind sie doch anders als ihre mathematischen Äquivalente. **Ein üblicher Fehler ist, das einfache Gleichheitszeichen (`=`) statt des doppelten Gleichheitszeichens (`==`) zu verwenden.** Wir merken uns: `=` ist der Zuweisungsoperator und `==` ist ein relationaler Operator. Die Operatoren `=<` und `=>` gibt es nicht.
![Note that this implies you should NOT honk solely because I stopped for a pedestrian and you&#39;re behind me.](https://imgs.xkcd.com/comics/formal_logic.png) ![Note that this implies you should NOT honk solely because I stopped for a pedestrian and you&#39;re behind me.](https://imgs.xkcd.com/comics/formal_logic.png)
([Formal Logic](https://xkcd.com/1033/), Randall Munroe) ([Formal Logic](https://xkcd.com/1033/), Randall Munroe)
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.3 Logische Operatoren ### 5.3 Logische Operatoren
Es gibt drei **logische Operatoren**: `and`, `or` und `not`. Die Semantik (Bedeutung) dieser drei Operatoren ist ähnlich der Bedeutung der englischen Wörter. Beispielsweise ist `x > 0 and x < 10` genau dann wahr, wenn `x` größer als 0 *und* kleiner als 10 ist. Es gibt drei **logische Operatoren**: `and`, `or` und `not`. Die Semantik (Bedeutung) dieser drei Operatoren ist ähnlich der Bedeutung der englischen Wörter. Beispielsweise ist `x > 0 and x < 10` genau dann wahr, wenn `x` größer als 0 *und* kleiner als 10 ist.
`n%2 == 0 or n%3 == 0` ist wahr, wenn *eine oder beide* der Bedingungen wahr ist, das heißt wenn die Zahl `n` durch 2 *oder* drei teilbar ist. `n%2 == 0 or n%3 == 0` ist wahr, wenn *eine oder beide* der Bedingungen wahr ist, das heißt wenn die Zahl `n` durch 2 *oder* drei teilbar ist.
Genaugenommen sollten die Operanden der logischen Operatoren Boolesche Ausdrücke sein, aber Python erlaubt uns da mehr Freiheit. Jede Zahl ungleich Null wird als `True` interpretiert: Genaugenommen sollten die Operanden der logischen Operatoren Boolesche Ausdrücke sein, aber Python erlaubt uns da mehr Freiheit. Jede Zahl ungleich Null wird als `True` interpretiert:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
42 and True 42 and True
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Diese Flexibilität kann nützlich sein, aber es gibt ein paar Feinheiten, die verwirrend sein könnten. Daher sollten Sie diese Variante eher vermeiden (außer, Sie wissen, was Sie tun). Diese Flexibilität kann nützlich sein, aber es gibt ein paar Feinheiten, die verwirrend sein könnten. Daher sollten Sie diese Variante eher vermeiden (außer, Sie wissen, was Sie tun).
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.4 Verzweigungen ### 5.4 Verzweigungen
Um nützliche Programme zu schreiben, benötigen wir fast immer die Möglichkeit, Bedingungen zu prüfen und das Verhalten des Programms entsprechend anzupassen. **Verzweigungen** ermöglichen uns dies. Die einfachste Form ist die `if`-Anweisung: Um nützliche Programme zu schreiben, benötigen wir fast immer die Möglichkeit, Bedingungen zu prüfen und das Verhalten des Programms entsprechend anzupassen. **Verzweigungen** ermöglichen uns dies. Die einfachste Form ist die `if`-Anweisung:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if x > 0: if x > 0:
print(x, 'ist eine positive Zahl') print(x, 'ist eine positive Zahl')
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Der Boolesche Ausdruck hinter `if` heißt **Bedingung**. Wenn die Bedingung wahr ist, wird die eingerückte Anweisung ausgeführt. Falls nicht, passiert nichts. Der Boolesche Ausdruck hinter `if` heißt **Bedingung**. Wenn die Bedingung wahr ist, wird die eingerückte Anweisung ausgeführt. Falls nicht, passiert nichts.
Fügen Sie im folgenden Beispiel eine Anweisung vor der Verzweigung ein, so dass die Bedingung erfüllt ist: Fügen Sie im folgenden Beispiel eine Anweisung vor der Verzweigung ein, so dass die Bedingung erfüllt ist:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if x % 2 == 0: if x % 2 == 0:
print("x ist eine gerade Zahl") print("x ist eine gerade Zahl")
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
`if`-Anweisungen haben die gleiche Struktur wie Funktionsdefinitionen: ein (Verzweigungs-)Kopf, gefolgt von einem eingerückten (Verzweigungs-)Rumpf. Anweisungen dieser Art werden **Verbundanweisungen** genannt. `if`-Anweisungen haben die gleiche Struktur wie Funktionsdefinitionen: ein (Verzweigungs-)Kopf, gefolgt von einem eingerückten (Verzweigungs-)Rumpf. Anweisungen dieser Art werden **Verbundanweisungen** genannt.
Die Anzahl an Anweisungen, die im Rumpf stehen können, ist nicht begrenzt, aber es muss mindestens eine Anweisung sein. Manchmal ist es nützlich, einen Rumpf ohne Anweisungen zu haben (üblicherweise als Platzhalter für Code, den wir noch schreiben wollen). In diesem Fall können wir die **`pass`**-Anweisung verwenden, die nichts tut: Die Anzahl an Anweisungen, die im Rumpf stehen können, ist nicht begrenzt, aber es muss mindestens eine Anweisung sein. Manchmal ist es nützlich, einen Rumpf ohne Anweisungen zu haben (üblicherweise als Platzhalter für Code, den wir noch schreiben wollen). In diesem Fall können wir die **`pass`**-Anweisung verwenden, die nichts tut:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if x < 0: if x < 0:
pass # TODO: Behandlung negativer Werte implementieren! pass # TODO: Behandlung negativer Werte implementieren!
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.5 Alternative Verzweigung ### 5.5 Alternative Verzweigung
Eine zweite Form der `if`-Anweisung ist die "alternative Verzweigung", bei der es zwei Möglichkeiten gibt und die Bedingung festlegt, welche davon ausgeführt wird. Die Syntax sieht folgendermaßen aus: Eine zweite Form der `if`-Anweisung ist die "alternative Verzweigung", bei der es zwei Möglichkeiten gibt und die Bedingung festlegt, welche davon ausgeführt wird. Die Syntax sieht folgendermaßen aus:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if x % 2 == 0: if x % 2 == 0:
print("x ist gerade") print("x ist gerade")
else: else:
print("x ist ungerade") print("x ist ungerade")
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Wenn der Rest bei der Division von `x` durch 2 gleich Null ist, dann wissen wir, dass `x` eine gerade Zahl ist und das Programm gibt eine entsprechende Meldung aus. Wenn die Bedingung falsch ist, wird die zweite Anweisung ausgeführt. Da die Bedingung entweder wahr oder falsch sein muss, wird genau eine der Alternativen ausgeführt. Diese Alternativen werden **Zweige** genannt, denn sie erzeugen eine Verzweigung im Kontrollfluss. Wenn der Rest bei der Division von `x` durch 2 gleich Null ist, dann wissen wir, dass `x` eine gerade Zahl ist und das Programm gibt eine entsprechende Meldung aus. Wenn die Bedingung falsch ist, wird die zweite Anweisung ausgeführt. Da die Bedingung entweder wahr oder falsch sein muss, wird genau eine der Alternativen ausgeführt. Diese Alternativen werden **Zweige** genannt, denn sie erzeugen eine Verzweigung im Kontrollfluss.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.6 Verkettete Verzweigungen ### 5.6 Verkettete Verzweigungen
Manchmal gibt es mehr als zwei Möglichkeiten und wir benötigen mehr als zwei Zweige. Eine Möglichkeit eine Berechnung dieser Art auszudrücken, sind sogenannte **verkettete Verzweigungen**: Manchmal gibt es mehr als zwei Möglichkeiten und wir benötigen mehr als zwei Zweige. Eine Möglichkeit eine Berechnung dieser Art auszudrücken, sind sogenannte **verkettete Verzweigungen**:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if x < y: if x < y:
print(x, 'x ist kleiner als', y) print(x, 'x ist kleiner als', y)
elif x > y: elif x > y:
print(x, 'ist größer als', y) print(x, 'ist größer als', y)
else: else:
print(x, 'und', y, 'sind gleich') print(x, 'und', y, 'sind gleich')
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
`elif` ist eine Abkürzung für `else if`. Wieder wird nur genau ein Zweig ausgeführt. Es gibt keine Begrenzung für die Anzahl der `elif`-Anweisungen. Falls es einen `else`-Teil gibt, so muss dieser am Ende stehen, aber es muss keinen geben: `elif` ist eine Abkürzung für `else if`. Wieder wird nur genau ein Zweig ausgeführt. Es gibt keine Begrenzung für die Anzahl der `elif`-Anweisungen. Falls es einen `else`-Teil gibt, so muss dieser am Ende stehen, aber es muss keinen geben:
```python ```python
if choice == 'a': if choice == 'a':
draw_a() draw_a()
elif choice == 'b': elif choice == 'b':
draw_b() draw_b()
elif choice == 'c': elif choice == 'c':
draw_c() draw_c()
``` ```
Jede Bedingung wird in der vorgegebenen Reihenfolge geprüft. Wenn die erste nicht erfüllt (falsch) ist, wird die nächste geprüft, und so weiter. Sobald eine der Bedingungen erfüllt (wahr) ist, wird der entsprechende Zweig ausgeführt und die `if`-Anweisung wird beendet. **Auch wenn mehr als eine Bedingung erfüllt ist, wird nur der erste zutreffende Zweig ausgeführt.** Jede Bedingung wird in der vorgegebenen Reihenfolge geprüft. Wenn die erste nicht erfüllt (falsch) ist, wird die nächste geprüft, und so weiter. Sobald eine der Bedingungen erfüllt (wahr) ist, wird der entsprechende Zweig ausgeführt und die `if`-Anweisung wird beendet. **Auch wenn mehr als eine Bedingung erfüllt ist, wird nur der erste zutreffende Zweig ausgeführt.**
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.7 Verschachtelte Verzweigungen ### 5.7 Verschachtelte Verzweigungen
Eine Verzweigung kann auch mit einer anderen verschachtelt sein. Wir könnten das Beispiel vom vorherigen Abschnitt auch so schreiben: Eine Verzweigung kann auch mit einer anderen verschachtelt sein. Wir könnten das Beispiel vom vorherigen Abschnitt auch so schreiben:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if x == y: if x == y:
print(x, 'und', y, 'sind gleich') print(x, 'und', y, 'sind gleich')
else: else:
if x < y: if x < y:
print(x, 'ist kleiner als', y) print(x, 'ist kleiner als', y)
else: else:
print(x, 'ist größer als', y) print(x, 'ist größer als', y)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Die äußere Verzweigung hat zwei Zweige: Die äußere Verzweigung hat zwei Zweige:
- Der erste Zweig enthält eine einfache `print`-Anweisung. - Der erste Zweig enthält eine einfache `print`-Anweisung.
- Der zweite Zweig enthält eine weitere `if`-Anweisung, die selbst zwei Zweige hat. Diese beiden Zweige sind beide einfache Anweisungen; sie könnten aber ebenfalls Verzweigungen enthalten. - Der zweite Zweig enthält eine weitere `if`-Anweisung, die selbst zwei Zweige hat. Diese beiden Zweige sind beide einfache Anweisungen; sie könnten aber ebenfalls Verzweigungen enthalten.
Auch wenn die Einrückung der Anweisungen die Struktur offensichtlich macht, werden **verschachtelte Verzweigungen** schnell schwer lesbar. Daher ist es eine gute Idee, sie möglichst zu vermeiden. Auch wenn die Einrückung der Anweisungen die Struktur offensichtlich macht, werden **verschachtelte Verzweigungen** schnell schwer lesbar. Daher ist es eine gute Idee, sie möglichst zu vermeiden.
Boolesche Operatoren bieten uns oft die Möglichkeit, verschachtelte Verzweigungen zu vereinfachen. Beispielsweise können wir den folgenden Code in eine einfach Verzweigung umschreiben: Boolesche Operatoren bieten uns oft die Möglichkeit, verschachtelte Verzweigungen zu vereinfachen. Beispielsweise können wir den folgenden Code in eine einfach Verzweigung umschreiben:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if 0 < x: if 0 < x:
if x < 10: if x < 10:
print(x, 'ist eine positive einstellige Zahl.') print(x, 'ist eine positive einstellige Zahl.')
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Die `print`-Anweisung wird nur ausgeführt, wenn beide Bedingungen erfüllt sind. Daher können wir den gleichen Effekt mit Hilfe des `and`-Operators erzeugen: Die `print`-Anweisung wird nur ausgeführt, wenn beide Bedingungen erfüllt sind. Daher können wir den gleichen Effekt mit Hilfe des `and`-Operators erzeugen:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if 0 < x and x < 10: if 0 < x and x < 10:
print(x, 'ist eine positive einstellige Zahl.') print(x, 'ist eine positive einstellige Zahl.')
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Für diese Art der Bedingung bietet Python sogar eine noch kürzere Schreibweise: Für diese Art der Bedingung bietet Python sogar eine noch kürzere Schreibweise:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if 0 < x < 10: if 0 < x < 10:
print(x, 'ist eine positive einstellige Zahl.') print(x, 'ist eine positive einstellige Zahl.')
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Schreiben Sie die folgende verschachtelte Verzweigung so um, dass nur noch eine Verzweigung verwendet wird: Schreiben Sie die folgende verschachtelte Verzweigung so um, dass nur noch eine Verzweigung verwendet wird:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
if x % 2 == 0: if x % 2 == 0:
if x % 4 == 0: if x % 4 == 0:
print(x, "ist durch 2 und 4 teilbar") print(x, "ist durch 2 und 4 teilbar")
else: else:
print(x, "ist nicht durch 2 oder 4 teilbar") print(x, "ist nicht durch 2 oder 4 teilbar")
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
# Fügen Sie hier Ihren Code ein # Fügen Sie hier Ihren Code ein
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.8 Rekursion ### 5.8 Rekursion
Um Rekursion zu verstehen, gehen Sie zu [Abschnitt 5.8](#5.8-Rekursion) und lesen Sie diesen. Um Rekursion zu verstehen, gehen Sie zu [Abschnitt 5.8](#5.8-Rekursion) und lesen Sie diesen.
![I may have also tossed one of a pair of teleportation rings into the ocean, with interesting results.](https://imgs.xkcd.com/comics/tabletop_roleplaying.png) ![I may have also tossed one of a pair of teleportation rings into the ocean, with interesting results.](https://imgs.xkcd.com/comics/tabletop_roleplaying.png)
([Tabletop Roleplaying](https://xkcd.com/244/), Randall Munroe) ([Tabletop Roleplaying](https://xkcd.com/244/), Randall Munroe)
Es ist erlaubt, dass eine Funktion eine andere aufruft; es ist auch erlaubt, dass die Funktion sich selbst aufruft. Es ist vielleicht nicht offensichtlich, warum das eine gute Idee ist, aber es ist eines der "magischsten" Dinge, die ein Program tun kann. Schauen wir uns beispielsweise die folgende Funktion an: Es ist erlaubt, dass eine Funktion eine andere aufruft; es ist auch erlaubt, dass die Funktion sich selbst aufruft. Es ist vielleicht nicht offensichtlich, warum das eine gute Idee ist, aber es ist eines der "magischsten" Dinge, die ein Program tun kann. Schauen wir uns beispielsweise die folgende Funktion an:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def countdown(n): def countdown(n):
if n <= 0: if n <= 0:
print("Abheben!") print("Abheben!")
else: else:
print(n) print(n)
countdown(n-1) countdown(n-1)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Wenn `n` Null oder negativ ist, gibt die Funktion "Abheben!" aus. Ansonsten wird `n` ausgegeben und eine Funktion `countdown` - die Funktion selbst - aufgerufen mit `n-1` als Argument. Wenn `n` Null oder negativ ist, gibt die Funktion "Abheben!" aus. Ansonsten wird `n` ausgegeben und eine Funktion `countdown` - die Funktion selbst - aufgerufen mit `n-1` als Argument.
Was passiert wenn wir diese Funktion folgendermaßen aufrufen? Was passiert wenn wir diese Funktion folgendermaßen aufrufen?
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
countdown(3) countdown(3)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Die Ausführung von `countdown` beginnt mit `n=3`. Da `n` größer als 0 ist, wird der Wert 3 ausgegeben und die Funktion ruft sich selber auf ... Die Ausführung von `countdown` beginnt mit `n=3`. Da `n` größer als 0 ist, wird der Wert 3 ausgegeben und die Funktion ruft sich selber auf ...
- Die Ausführung von `countdown` beginnt mit `n=2`. Da `n` größer als 0 ist, wird der Wert 2 ausgegeben und die Funktion ruft sich selber auf ... - Die Ausführung von `countdown` beginnt mit `n=2`. Da `n` größer als 0 ist, wird der Wert 2 ausgegeben und die Funktion ruft sich selber auf ...
- Die Ausführung von `countdown` beginnt mit `n=1`. Da `n` größer als 0 ist, wird der Wert 1 ausgegeben und die Funktion ruft sich selber auf ... - Die Ausführung von `countdown` beginnt mit `n=1`. Da `n` größer als 0 ist, wird der Wert 1 ausgegeben und die Funktion ruft sich selber auf ...
- Die Ausführung von `countdown` beginnt mit `n=0`. Da `n` nicht größer als 0 ist, wird "Abheben!" ausgegeben und zurückgesprungen. - Die Ausführung von `countdown` beginnt mit `n=0`. Da `n` nicht größer als 0 ist, wird "Abheben!" ausgegeben und zurückgesprungen.
Die Funktion `countdown` mit `n=1` springt zurück. Die Funktion `countdown` mit `n=1` springt zurück.
Die Funktion `countdown` mit `n=2` springt zurück. Die Funktion `countdown` mit `n=2` springt zurück.
Die Funktion `countdown` mit `n=3` springt zurück. Die Funktion `countdown` mit `n=3` springt zurück.
Und damit sind wir zurück im `__main__`. Die Ausgabe des Aufrufs sieht damit so aus: Und damit sind wir zurück im `__main__`. Die Ausgabe des Aufrufs sieht damit so aus:
``` ```
3 3
2 2
1 1
Abheben! Abheben!
``` ```
Eine Funktion die sich selbst aufruft wird **rekursiv** genannt; der Vorgang wird **Rekursion** genannt. Eine Funktion die sich selbst aufruft wird **rekursiv** genannt; der Vorgang wird **Rekursion** genannt.
**Es ist wichtig, dass Sie dieses Beispiel verstanden haben. Falls das nicht der Fall sein sollte, lassen Sie es sich von Ihrem Partner, Kommilitonen oder Übungsleiter erklären.** **Es ist wichtig, dass Sie dieses Beispiel verstanden haben. Falls das nicht der Fall sein sollte, lassen Sie es sich von Ihrem Partner, Kommilitonen oder Übungsleiter erklären.**
Eine gute Hilfe ist außerdem diese Webseite: http://www.pythontutor.com. Eine gute Hilfe ist außerdem diese Webseite: http://www.pythontutor.com.
Dort können Sie ihren Python Code hochladen und Schritt für Schritt durchführen. Dort können Sie ihren Python Code hochladen und Schritt für Schritt durchführen.
Probieren Sie es mit der Funktion countdown() aus *(Achtung: Sie müssen die Funktion auch dort aufrufen)*. Probieren Sie es mit der Funktion countdown() aus *(Achtung: Sie müssen die Funktion auch dort aufrufen)*.
Als weiteres Beispiel schreiben wir eine Funktion, die eine Zeichenkette `n` mal ausgibt: Als weiteres Beispiel schreiben wir eine Funktion, die eine Zeichenkette `n` mal ausgibt:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def print_n(s, n): def print_n(s, n):
if n <= 0: if n <= 0:
return return
print(s) print(s)
print_n(s, n-1) print_n(s, n-1)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Wenn `n <= 0` ist, dann beendet die **return-Anweisung** die Funktion. Der Kontrollfluss kehrt dann sofort zur aufrufenden Stelle zurück und die übrigen Anweisungen in der Funktion werden nicht ausgeführt. Wenn `n <= 0` ist, dann beendet die **return-Anweisung** die Funktion. Der Kontrollfluss kehrt dann sofort zur aufrufenden Stelle zurück und die übrigen Anweisungen in der Funktion werden nicht ausgeführt.
Der Rest der Funktion ist ähnlich zu `countdown`: `s` wird ausgegeben und dann ruft die Funktion sich selbst auf, um `s` `n-1` mal auszugeben. Die Anzahl der Zeilen die ausgegeben werden ist also 1 + (n - 1), was gleich `n` ist. Der Rest der Funktion ist ähnlich zu `countdown`: `s` wird ausgegeben und dann ruft die Funktion sich selbst auf, um `s` `n-1` mal auszugeben. Die Anzahl der Zeilen die ausgegeben werden ist also 1 + (n - 1), was gleich `n` ist.
Für solche einfachen Beispiele ist es wohl einfacher, eine `for`-Schleife zu verwenden. Aber wir werden später Beispiele sehen, die eher schwierig mit einer `for`-Schleife zu implementieren sind, jedoch sehr einfach mittels Rekursion. Für solche einfachen Beispiele ist es wohl einfacher, eine `for`-Schleife zu verwenden. Aber wir werden später Beispiele sehen, die eher schwierig mit einer `for`-Schleife zu implementieren sind, jedoch sehr einfach mittels Rekursion.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.9 Stapeldiagramme für rekursive Funktionen ### 5.9 Stapeldiagramme für rekursive Funktionen
In [Abschnitt 3.9](seminar03.ipynb#3.9-Stapel-Diagramme) haben wir Stapeldiagramme genutzt, um den Zustand eines Programms während eines Funktionsaufrufs zu repräsentieren. Die gleiche Art Diagramm kann uns helfen, eine rekursive Funktion zu interpretieren. In [Abschnitt 3.9](seminar03.ipynb#3.9-Stapel-Diagramme) haben wir Stapeldiagramme genutzt, um den Zustand eines Programms während eines Funktionsaufrufs zu repräsentieren. Die gleiche Art Diagramm kann uns helfen, eine rekursive Funktion zu interpretieren.
Jedes Mal, wenn eine Funktion aufgerufen wird, erstellt Python einen Block, der die lokalen Variablen und Parameter der Funktion enthält. Für eine rekursive Funktion kann es zur gleichen Zeit mehrere Blöcke auf dem Stapel geben. Jedes Mal, wenn eine Funktion aufgerufen wird, erstellt Python einen Block, der die lokalen Variablen und Parameter der Funktion enthält. Für eine rekursive Funktion kann es zur gleichen Zeit mehrere Blöcke auf dem Stapel geben.
Die folgende Abbildung zeigt ein Stapeldiagramm für den Aufruf von `countdown(3)`: Die folgende Abbildung zeigt ein Stapeldiagramm für den Aufruf von `countdown(3)`:
![Stapel-Diagramm](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/stapeldiagramm_countdown.svg) ![Stapel-Diagramm](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/stapeldiagramm_countdown.svg)
Wie üblich, ist oben auf dem Stapel der Block für `__main__`. Dieser ist leer, denn wir haben in `main` keine Variablen erstellt oder Argumente übergeben. Wie üblich, ist oben auf dem Stapel der Block für `__main__`. Dieser ist leer, denn wir haben in `main` keine Variablen erstellt oder Argumente übergeben.
Die vier Blöcke für `countdown` haben unterschiedliche Werte für den Parameter `n`. Der Block am Boden des Stapels, wo `n=0` ist, wird **Basisfall** genannt. In diesem gibt es keinen rekursiven Aufruf, daher gibt es keine weiteren Blöcke. Dies ist gleichzeitig die **Abbruchbedingung** für die Rekursion. Die vier Blöcke für `countdown` haben unterschiedliche Werte für den Parameter `n`. Der Block am Boden des Stapels, wo `n=0` ist, wird **Basisfall** genannt. In diesem gibt es keinen rekursiven Aufruf, daher gibt es keine weiteren Blöcke. Dies ist gleichzeitig die **Abbruchbedingung** für die Rekursion.
Zeichnen Sie als Übung ein Stapeldiagramm für `print_n`, wenn es mit `s = 'Hallo'` und `n = 2` aufgerufen wird. Zeichnen Sie als Übung ein Stapeldiagramm für `print_n`, wenn es mit `s = 'Hallo'` und `n = 2` aufgerufen wird.
Schreiben Sie dann eine Funktion `do_n`, die ein Funktionsobjekt und eine ganze Zahl `n` als Parameter erwartet und dann die übergebene Funktion `n`-mal aufruft. *(Funktionsobjekte wurden im [3. Kapitel](seminar03.ipynb) erklärt und dort beispielsweise in [Aufgabe 2](seminar03.ipynb#Aufgabe-2) verwendet.)* Schreiben Sie dann eine Funktion `do_n`, die ein Funktionsobjekt und eine ganze Zahl `n` als Parameter erwartet und dann die übergebene Funktion `n`-mal aufruft. *(Funktionsobjekte wurden im [3. Kapitel](seminar03.ipynb) erklärt und dort beispielsweise in [Aufgabe 2](seminar03.ipynb#Aufgabe-2) verwendet.)*
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
# implementieren Sie hier die Funktion do_n # implementieren Sie hier die Funktion do_n
# eine Testfunktion # eine Testfunktion
def testfunktion(): def testfunktion():
print("Ich wurde aufgerufen!") print("Ich wurde aufgerufen!")
# rufen Sie hier die Funktion do_n auf, indem Sie die Funktion testfunktion sowie den Wert 7 als Argument übergeben # rufen Sie hier die Funktion do_n auf, indem Sie die Funktion testfunktion sowie den Wert 7 als Argument übergeben
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.10 Unendliche Rekursion ### 5.10 Unendliche Rekursion
Wenn die Rekursion niemals den Basisfall erreicht, werden immer wieder rekursive Aufrufe getätigt und das Programm wird nicht beendet. Dies wird **unendliche Rekursion** genannt und ist im Allgemeinen keine gute Idee. Das hier ist ein minimales Programm mit unendlicher Rekursion: Wenn die Rekursion niemals den Basisfall erreicht, werden immer wieder rekursive Aufrufe getätigt und das Programm wird nicht beendet. Dies wird **unendliche Rekursion** genannt und ist im Allgemeinen keine gute Idee. Das hier ist ein minimales Programm mit unendlicher Rekursion:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def recurse(): def recurse():
recurse() recurse()
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
In den meisten Ausführungsumgebungen läuft ein Programm mit unendlicher Rekursion nicht wirklich für immer. Python gibt uns eine Fehlermeldung aus wenn die maximale Rekursionstiefe erreicht ist: In den meisten Ausführungsumgebungen läuft ein Programm mit unendlicher Rekursion nicht wirklich für immer. Python gibt uns eine Fehlermeldung aus wenn die maximale Rekursionstiefe erreicht ist:
``` ```
Traceback (most recent call last): Traceback (most recent call last):
File "<stdin>", line 1, in <module> File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in recurse File "<stdin>", line 2, in recurse
File "<stdin>", line 2, in recurse File "<stdin>", line 2, in recurse
. .
. .
. .
File "<stdin>", line 2, in recurse File "<stdin>", line 2, in recurse
RecursionError: maximum recursion depth exceeded RecursionError: maximum recursion depth exceeded
``` ```
Dieser Traceback ist etwas größer als der, den wir im vorherigen Kapitel gesehen haben. Wenn der Fehler auftritt, befinden sich 1000 `recurse`-Blöcke auf dem Stapel! Dieser Traceback ist etwas größer als der, den wir im vorherigen Kapitel gesehen haben. Wenn der Fehler auftritt, befinden sich 1000 `recurse`-Blöcke auf dem Stapel!
Wenn bei ihnen eine ungewollte unendliche Rekursion auftritt, überprüfen Sie Ihre Funktion und stellen Sie sicher, dass es einen Basisfall gibt, der keinen rekursiven Aufruf tätigt. Und wenn es einen Basisfall gibt, überprüfen Sie, ob er garantiert erreicht wird. Wenn bei ihnen eine ungewollte unendliche Rekursion auftritt, überprüfen Sie Ihre Funktion und stellen Sie sicher, dass es einen Basisfall gibt, der keinen rekursiven Aufruf tätigt. Und wenn es einen Basisfall gibt, überprüfen Sie, ob er garantiert erreicht wird.
![Mandelbrot Detail](https://upload.wikimedia.org/wikipedia/commons/thumb/b/b3/Mandel_zoom_07_satellite.jpg/800px-Mandel_zoom_07_satellite.jpg) ![Mandelbrot Detail](https://upload.wikimedia.org/wikipedia/commons/thumb/b/b3/Mandel_zoom_07_satellite.jpg/800px-Mandel_zoom_07_satellite.jpg)
([Wolfgang Beyer](https://commons.wikimedia.org/wiki/File:Mandel_zoom_07_satellite.jpg)) ([Wolfgang Beyer](https://commons.wikimedia.org/wiki/File:Mandel_zoom_07_satellite.jpg))
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.11 Tastatur-Eingaben ### 5.11 Tastatur-Eingaben
Die meisten Programme, die wir bisher geschrieben haben, akzeptieren keine Eingaben durch die Nutzerin. Sie erledigen jedesmal die gleiche Aufgabe. Die meisten Programme, die wir bisher geschrieben haben, akzeptieren keine Eingaben durch die Nutzerin. Sie erledigen jedesmal die gleiche Aufgabe.
Python bietet eine eingebaute Funktion namens `input` die das Programm pausiert und darauf wartet, dass der Nutzer etwas eintippt. Wenn der Nutzer *Return* oder *Enter* drückt, fährt das Programm fort und `input` gibt was immer der Nutzer eingetippt hat als Zeichenkette zurück. Python bietet eine eingebaute Funktion namens `input` die das Programm pausiert und darauf wartet, dass der Nutzer etwas eintippt. Wenn der Nutzer *Return* oder *Enter* drückt, fährt das Programm fort und `input` gibt was immer der Nutzer eingetippt hat als Zeichenkette zurück.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
text = input() text = input()
print(text) print(text)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Bevor man von der Nutzerin eine Eingabe bekommt, ist es eine gute Idee, einen Hinweis auszugeben, der der Nutzerin sagt, was Sie eintippen soll. Der Funktion `input` können wir einen solchen Hinweis als Argument übergeben: Bevor man von der Nutzerin eine Eingabe bekommt, ist es eine gute Idee, einen Hinweis auszugeben, der der Nutzerin sagt, was Sie eintippen soll. Der Funktion `input` können wir einen solchen Hinweis als Argument übergeben:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
name = input("Wie lautet Ihr Name?\n") name = input("Wie lautet Ihr Name?\n")
print(name) print(name)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Die Folge `\n` am Ende des Hinweises repräsentiert einen **Zeilenumbruch** - ein spezielles Zeichen, welches einen Zeilenumbruch bewirkt. Aus diesem Grund erscheint die Eingabe des Nutzers unter dem Hinweis. Die Folge `\n` am Ende des Hinweises repräsentiert einen **Zeilenumbruch** - ein spezielles Zeichen, welches einen Zeilenumbruch bewirkt. Aus diesem Grund erscheint die Eingabe des Nutzers unter dem Hinweis.
Falls wir erwarten, dass der Nutzer eine ganze Zahl eintippt, können wir versuchen, die Eingabe in eine ganze Zahl umzuwandeln: Falls wir erwarten, dass der Nutzer eine ganze Zahl eintippt, können wir versuchen, die Eingabe in eine ganze Zahl umzuwandeln:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
prompt = "Wie hoch ist die Fluggeschwindigkeit einer unbeladenen Schwalbe?\n" prompt = "Wie hoch ist die Fluggeschwindigkeit einer unbeladenen Schwalbe?\n"
speed = input(prompt) speed = input(prompt)
int(speed) int(speed)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Wenn der Nutzer etwas anderes als eine Zeichenkette mit Ziffern eintippt, erhalten wir einen Fehler: Wenn der Nutzer etwas anderes als eine Zeichenkette mit Ziffern eintippt, erhalten wir einen Fehler:
``` ```
ValueError: invalid literal for int() with base 10: 'Eine afrikanische oder eine europäische Schwalbe?' ValueError: invalid literal for int() with base 10: 'Eine afrikanische oder eine europäische Schwalbe?'
``` ```
Wir werden später sehen, wie wir diese Art von Fehler behandeln können. Wir werden später sehen, wie wir diese Art von Fehler behandeln können.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
from IPython.display import YouTubeVideo from IPython.display import YouTubeVideo
YouTubeVideo('liIlW-ovx0Y') YouTubeVideo('liIlW-ovx0Y')
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.12 Debugging ### 5.12 Debugging
Wenn ein Syntax- oder Laufzeitfehler auftritt, enthält die Fehlermeldung oft eine überwältigende Menge an Information. Die hilfreichsten Teile davon sind üblicherweise: Wenn ein Syntax- oder Laufzeitfehler auftritt, enthält die Fehlermeldung oft eine überwältigende Menge an Information. Die hilfreichsten Teile davon sind üblicherweise:
- Welcher Art von Fehler aufgetreten ist und - Welcher Art von Fehler aufgetreten ist und
- wo der Fehler aufgetreten ist. - wo der Fehler aufgetreten ist.
Syntaxfehler sind üblicherweise leichter zu finden, aber es gibt ein paar knifflige Fälle. Probleme mit Leerzeichen können schwierig zu finden sein, denn Leerzeichen (und auch Tabs) sind unsichtbar und wir ignorieren sie üblicherweise. Syntaxfehler sind üblicherweise leichter zu finden, aber es gibt ein paar knifflige Fälle. Probleme mit Leerzeichen können schwierig zu finden sein, denn Leerzeichen (und auch Tabs) sind unsichtbar und wir ignorieren sie üblicherweise.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
x = 5 x = 5
y = 6 y = 6
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
In diesem Beispiel ist das Problem, dass die zweite Zeile durch ein Leerzeichen eingerückt ist. Aber die Fehlermeldung zeigt auf `y`, was verwirrend ist. Im allgemeinen gibt eine Fehlermeldung an, wo das Problem entdeckt wurde, aber der tatsächliche Fehler kann sich weiter vorne im Code befinden, manchmal auch in der vorhergehenden Zeile. In diesem Beispiel ist das Problem, dass die zweite Zeile durch ein Leerzeichen eingerückt ist. Aber die Fehlermeldung zeigt auf `y`, was verwirrend ist. Im allgemeinen gibt eine Fehlermeldung an, wo das Problem entdeckt wurde, aber der tatsächliche Fehler kann sich weiter vorne im Code befinden, manchmal auch in der vorhergehenden Zeile.
Das gleiche gilt für Laufzeitfehler. Angenommen, wir versuchen das Signal-Rausch-Verhältnis in Dezibel zu berechnen. Die Formel dafür ist $SNR_{db} = 10\log_{10}(P_{signal}/P_{noise})$. In Python könnten wir das so aufschreiben: Das gleiche gilt für Laufzeitfehler. Angenommen, wir versuchen das Signal-Rausch-Verhältnis in Dezibel zu berechnen. Die Formel dafür ist $SNR_{db} = 10\log_{10}(P_{signal}/P_{noise})$. In Python könnten wir das so aufschreiben:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
import math import math
signal_power = 9 signal_power = 9
noise_power = 10 noise_power = 10
ratio = signal_power // noise_power ratio = signal_power // noise_power
decibels = 10 * math.log10(ratio) decibels = 10 * math.log10(ratio)
print(decibels) print(decibels)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Wenn wir dieses Programm ausführen, erhalten wir einen Fehler: Wenn wir dieses Programm ausführen, erhalten wir einen Fehler:
``` ```
Traceback (most recent call last) Traceback (most recent call last)
<ipython-input-53-b5706bfbb8ff> in <module>() <ipython-input-53-b5706bfbb8ff> in <module>()
3 noise_power = 10 3 noise_power = 10
4 ratio = signal_power // noise_power 4 ratio = signal_power // noise_power
----> 5 decibels = 10 * math.log10(ratio) ----> 5 decibels = 10 * math.log10(ratio)
6 print(decibels) 6 print(decibels)
ValueError: math domain error ValueError: math domain error
``` ```
Die Fehlermeldung gibt Zeile 5 an, aber in dieser Zeile befindet sich kein Fehler. Um den tatsächlichen Fehler zu finden könnte es hilfreich sein, den Wert von `ratio` mit Hilfe der `print`-Funktion auszugeben. Tatsächlich ist der Wert 0. Das Problem ist also in Zeile 4, da dort Ganzzahldivision statt Gleitkommadivision genutzt wird. Die Fehlermeldung gibt Zeile 5 an, aber in dieser Zeile befindet sich kein Fehler. Um den tatsächlichen Fehler zu finden könnte es hilfreich sein, den Wert von `ratio` mit Hilfe der `print`-Funktion auszugeben. Tatsächlich ist der Wert 0. Das Problem ist also in Zeile 4, da dort Ganzzahldivision statt Gleitkommadivision genutzt wird.
Sie sollten sich die Zeit nehmen und Fehlermeldungen sorgfältig durchlesen aber nicht davon ausgehen, dass alles was darin steht richtig ist. Sie sollten sich die Zeit nehmen und Fehlermeldungen sorgfältig durchlesen aber nicht davon ausgehen, dass alles was darin steht richtig ist.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.13 Glossar ### 5.13 Glossar
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 5 gelernt haben: Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 5 gelernt haben:
- Ganzzahldivision: - Ganzzahldivision:
- Restoperator: Ein Operator, bezeichnet durch ein Prozentzeichen (`%`), der auf ganzen Zahlen operiert und als Ergebnis den Rest zurückliefert, der sich bei Division der einen durch die andere Zahl ergibt. - Restoperator: Ein Operator, bezeichnet durch ein Prozentzeichen (`%`), der auf ganzen Zahlen operiert und als Ergebnis den Rest zurückliefert, der sich bei Division der einen durch die andere Zahl ergibt.
- Boolescher Ausdruck: - Boolescher Ausdruck:
- relationaler Operator: - relationaler Operator:
- logischer Operator: - logischer Operator:
- Verzweigung: - Verzweigung:
- Bedingung: - Bedingung:
- Verbundanweisung: - Verbundanweisung:
- Zweig: - Zweig:
- verkettete Verzweigung: - verkettete Verzweigung:
- verschachtelte Verzweigung: - verschachtelte Verzweigung:
- `return`-Anweisung - `return`-Anweisung
- Rekursion: - Rekursion:
- Basisfall: - Basisfall:
- unendliche Rekursion: - unendliche Rekursion:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit. Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 5.14 Übung ### 5.14 Übung
#### Aufgabe 1 #### Aufgabe 1
Das Modul `time` bietet eine Funktion, die ebenfalls `time` heißt, und die uns für die Zeitzone Greenwich Mean Time die Zeit (in Sekunden) zurückliefert, die seit einem Referenzpunkt vergangen ist. Der Referenzpunkt ist ziemlich willkürlich gewählt und ist meistens der 1. Januar 1970. Das Modul `time` bietet eine Funktion, die ebenfalls `time` heißt, und die uns für die Zeitzone Greenwich Mean Time die Zeit (in Sekunden) zurückliefert, die seit einem Referenzpunkt vergangen ist. Der Referenzpunkt ist ziemlich willkürlich gewählt und ist meistens der 1. Januar 1970.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
import time import time
time.time() time.time()
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Schreiben Sie eine Funktion `print_time`, die die aktuelle Zeit mit Hilfe von `time` abfragt und diese in eine Tageszeit in Stunden, Minuten und Sekunden sowie die Anzahl der Tage die seit dem Referenzpunkt vergangen sind konvertiert und diese Werte ausgibt: Schreiben Sie eine Funktion `print_time`, die die aktuelle Zeit mit Hilfe von `time` abfragt und diese in eine Tageszeit in Stunden, Minuten und Sekunden sowie die Anzahl der Tage die seit dem Referenzpunkt vergangen sind konvertiert und diese Werte ausgibt:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
import time import time
# Testaufruf # Testaufruf
print_time() print_time()
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![If only we&#39;d chosen 1944-12-02 08:45:52 as the Unix epoch, we could&#39;ve combined two doomsday scenarios into one and added a really boring scene to that Roland Emmerich movie.](https://imgs.xkcd.com/comics/2038.png) ![If only we&#39;d chosen 1944-12-02 08:45:52 as the Unix epoch, we could&#39;ve combined two doomsday scenarios into one and added a really boring scene to that Roland Emmerich movie.](https://imgs.xkcd.com/comics/2038.png)
([2038](https://xkcd.com/607/), Randall Munroe) ([2038](https://xkcd.com/607/), Randall Munroe)
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
#### Aufgabe 2 #### Aufgabe 2
![Pierre de Fermat](https://upload.wikimedia.org/wikipedia/commons/f/f3/Pierre_de_Fermat.jpg) ![Pierre de Fermat](https://upload.wikimedia.org/wikipedia/commons/f/f3/Pierre_de_Fermat.jpg)
[Fermats letzter Satz](https://de.wikipedia.org/wiki/Gro%C3%9Fer_Fermatscher_Satz) besagt dass es keine positiven ganzen Zahlen $a$,$b$ und $c$ gibt, so dass [Fermats letzter Satz](https://de.wikipedia.org/wiki/Gro%C3%9Fer_Fermatscher_Satz) besagt dass es keine positiven ganzen Zahlen $a$,$b$ und $c$ gibt, so dass
\begin{equation} \begin{equation}
a^n + b^n = c^n a^n + b^n = c^n
\end{equation} \end{equation}
für alle $n$ größer 2 gilt. für alle $n$ größer 2 gilt.
1. Schreiben Sie eine Funktion `check_fermat` die vier Parameter erwartet - `a`, `b`, `c` und `n` - und prüft, ob Fermats letzter Satz gilt. Falls `n` größer als 2 ist und $a^n + b^n = c^n$ gilt, sollte das Programm "Unglaublich, Fermat lag falsch!" ausgeben, ansonsten "Nein, das funktioniert nicht." 1. Schreiben Sie eine Funktion `check_fermat` die vier Parameter erwartet - `a`, `b`, `c` und `n` - und prüft, ob Fermats letzter Satz gilt. Falls `n` größer als 2 ist und $a^n + b^n = c^n$ gilt, sollte das Programm "Unglaublich, Fermat lag falsch!" ausgeben, ansonsten "Nein, das funktioniert nicht."
2. Schreiben Sie eine Funktion, die den Nutzer bittet, Werte für a, b, c und n einzugeben, diese in ganze Zahlen umwandelt und dann die Funktion `check_fermat` nutzt, um zu prüfen, ob sie Fermats letzten Satz erfüllen. 2. Schreiben Sie eine Funktion, die den Nutzer bittet, Werte für a, b, c und n einzugeben, diese in ganze Zahlen umwandelt und dann die Funktion `check_fermat` nutzt, um zu prüfen, ob sie Fermats letzten Satz erfüllen.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
#### Aufgabe 3 #### Aufgabe 3
Wenn uns drei Stöcke gegeben werden, kann es sein, dass wir sie als Dreieck anordnen können oder auch nicht. Wenn beispielsweise einer der Stöcke 12cm lang ist und die anderen beiden jeweils 1cm, dann klappt es nicht. Für jede Kombination von Längen gibt es einen einfachen Test, der uns anzeigt, ob sich daraus ein Dreieck formen lässt: Wenn uns drei Stöcke gegeben werden, kann es sein, dass wir sie als Dreieck anordnen können oder auch nicht. Wenn beispielsweise einer der Stöcke 12cm lang ist und die anderen beiden jeweils 1cm, dann klappt es nicht. Für jede Kombination von Längen gibt es einen einfachen Test, der uns anzeigt, ob sich daraus ein Dreieck formen lässt:
*Falls eine der drei Längen größer als die Summe der anderen beiden Längen ist, dann lässt sich kein Dreieck formen. (Wenn die Summe der beiden Längen gleich der dritten Länge ist, dann bilden Sie ein sogenanntes "degeneriertes" Dreieck.)* *Falls eine der drei Längen größer als die Summe der anderen beiden Längen ist, dann lässt sich kein Dreieck formen. (Wenn die Summe der beiden Längen gleich der dritten Länge ist, dann bilden Sie ein sogenanntes "degeneriertes" Dreieck.)*
1. Schreiben Sie eine Funktion `is_triangle` die drei ganze Zahlen als Argumente erwartet und dann entweder "Ja" oder "Nein" ausgibt, abhängig davon, ob man mit den gegebenen Längen ein Dreieck formen kann oder nicht. 1. Schreiben Sie eine Funktion `is_triangle` die drei ganze Zahlen als Argumente erwartet und dann entweder "Ja" oder "Nein" ausgibt, abhängig davon, ob man mit den gegebenen Längen ein Dreieck formen kann oder nicht.
2. Schreiben Sie eine Funktion, die die Nutzerin bittet, drei Längen einzugeben, diese in ganze Zahlen umwandelt und dann `is_triangle` nutzt, um zu prüfen, ob aus Stöcken mit den gegebenen Längen ein Dreieck geformt werden kann oder nicht. 2. Schreiben Sie eine Funktion, die die Nutzerin bittet, drei Längen einzugeben, diese in ganze Zahlen umwandelt und dann `is_triangle` nutzt, um zu prüfen, ob aus Stöcken mit den gegebenen Längen ein Dreieck geformt werden kann oder nicht.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
#### Aufgabe 4 #### Aufgabe 4
Was gibt das folgende Programm aus? Zeichnen Sie (mit Stift und Papier) ein Stapeldiagramm, das den Zustand des Programms ausgibt, wenn `recurse(3, 0)` aufgerufen wird: Was gibt das folgende Programm aus? Zeichnen Sie (mit Stift und Papier) ein Stapeldiagramm, das den Zustand des Programms ausgibt, wenn `recurse(3, 0)` aufgerufen wird:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def recurse(n, s): def recurse(n, s):
if n == 0: if n == 0:
print(s) print(s)
else: else:
recurse(n-1, n+s) recurse(n-1, n+s)
recurse(3, 0) recurse(3, 0)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
1. Was würde passieren, wenn wir diese Funktion so aufrufen würden: `recurse(-1, 0)`? 1. Was würde passieren, wenn wir diese Funktion so aufrufen würden: `recurse(-1, 0)`?
2. Schreiben Sie einen Docstring der alles erklärt, was man wissen sollte, um diese Funktion nutzen zu können (und nicht mehr!). 2. Schreiben Sie einen Docstring der alles erklärt, was man wissen sollte, um diese Funktion nutzen zu können (und nicht mehr!).
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Die folgenden Aufgaben nutzen das `turtle`-Modul welches in [Kapitel 4](seminar04.ipynb) beschrieben wurde. Die folgenden Aufgaben nutzen das `turtle`-Modul welches in [Kapitel 4](seminar04.ipynb) beschrieben wurde.
#### Aufgabe 5 #### Aufgabe 5
Lesen Sie sich die folgende Funktion durch und versuchen Sie herauszufinden, was sie tut (schauen Sie sich auch die [Beispiele in Kapitel 4](seminar04.ipynb#4.12-%C3%9Cbung) an). Rufen Sie erst dann die Funktion auf und schauen Sie, ob Sie richtig liegen. Lesen Sie sich die folgende Funktion durch und versuchen Sie herauszufinden, was sie tut (schauen Sie sich auch die [Beispiele in Kapitel 4](seminar04.ipynb#4.12-%C3%9Cbung) an). Rufen Sie erst dann die Funktion auf und schauen Sie, ob Sie richtig liegen.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def draw(t, length, n): def draw(t, length, n):
if n == 0: if n == 0:
return return
angle = 50 angle = 50
t.fd(length*n) t.fd(length*n)
t.lt(angle) t.lt(angle)
draw(t, length, n-1) draw(t, length, n-1)
t.rt(2*angle) t.rt(2*angle)
draw(t, length, n-1) draw(t, length, n-1)
t.lt(angle) t.lt(angle)
t.bk(length*n) t.bk(length*n)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![Pythagoras-Baum](https://upload.wikimedia.org/wikipedia/commons/thumb/8/89/Pythagoras_baum_Filled.png/610px-Pythagoras_baum_Filled.png) ![Pythagoras-Baum](https://upload.wikimedia.org/wikipedia/commons/thumb/8/89/Pythagoras_baum_Filled.png/610px-Pythagoras_baum_Filled.png)
#### Aufgabe 6 #### Aufgabe 6
Die [Koch-Kurve](https://de.wikipedia.org/wiki/Koch-Kurve) ist ein [Fraktal](https://de.wikipedia.org/wiki/Fraktal), welches ungefähr so aussieht: Die [Koch-Kurve](https://de.wikipedia.org/wiki/Koch-Kurve) ist ein [Fraktal](https://de.wikipedia.org/wiki/Fraktal), welches ungefähr so aussieht:
![Kochkurve](http://greenteapress.com/thinkpython2/html/thinkpython2006.png) ![Kochkurve](http://greenteapress.com/thinkpython2/html/thinkpython2006.png)
Um eine Koch-Kurve der Länge x zu zeichnen, müssen wir nur folgendes tun: Um eine Koch-Kurve der Länge x zu zeichnen, müssen wir nur folgendes tun:
1. Eine Koch-Kurve der Länge x/3 zeichnen. 1. Eine Koch-Kurve der Länge x/3 zeichnen.
2. Um 60° nach links drehen. 2. Um 60° nach links drehen.
3. Eine Koch-Kurve der Länge x/3 zeichnen. 3. Eine Koch-Kurve der Länge x/3 zeichnen.
2. Um 120° nach rechts drehen. 2. Um 120° nach rechts drehen.
3. Eine Koch-Kurve der Länge x/3 zeichnen. 3. Eine Koch-Kurve der Länge x/3 zeichnen.
2. Um 60° nach links drehen. 2. Um 60° nach links drehen.
3. Eine Koch-Kurve der Länge x/3 zeichnen. 3. Eine Koch-Kurve der Länge x/3 zeichnen.
Eine Ausnahme gibt es, falls x kleiner als 3 ist: dann zeichnen wir einfach eine Strecke der Länge 3. Eine Ausnahme gibt es, falls x kleiner als 3 ist: dann zeichnen wir einfach eine Strecke der Länge 3.
1. Schreiben Sie eine Funktion `koch`, die eine Schildkröte und eine Länge als Argumente erwartet und die Schildkröte nutzt, um eine Koch-Kurve der gegebenen Länge zu zeichnen. 1. Schreiben Sie eine Funktion `koch`, die eine Schildkröte und eine Länge als Argumente erwartet und die Schildkröte nutzt, um eine Koch-Kurve der gegebenen Länge zu zeichnen.
2. Schreiben Sie eine Funktion `schneeflocke`, die drei Koch-Kurven zeichnet, so dass sich der Umriss einer Schneeflocke ergibt. 2. Schreiben Sie eine Funktion `schneeflocke`, die drei Koch-Kurven zeichnet, so dass sich der Umriss einer Schneeflocke ergibt.
Lösung: http://thinkpython2.com/code/koch.py Lösung: http://thinkpython2.com/code/koch.py
3. Die Koch-Kurve kann auf verschiedene Art und Wiese verallgemeinert werden. Schauen Sie sich die [Beispiele auf Wikipedia](https://en.wikipedia.org/wiki/Koch_snowflake#Variants_of_the_Koch_curve) an und implementieren Sie ihren Favoriten. 3. Die Koch-Kurve kann auf verschiedene Art und Wiese verallgemeinert werden. Schauen Sie sich die [Beispiele auf Wikipedia](https://en.wikipedia.org/wiki/Koch_snowflake#Variants_of_the_Koch_curve) an und implementieren Sie ihren Favoriten.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
import turtle import turtle
# Implementieren Sie hier die Funktion koch # Implementieren Sie hier die Funktion koch
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![Koch-Kurve in 3D](https://upload.wikimedia.org/wikipedia/commons/thumb/3/39/Koch_Curve_in_Three_Dimensions_%28%22Delta%22_fractal%29.jpg/480px-Koch_Curve_in_Three_Dimensions_%28%22Delta%22_fractal%29.jpg) ![Koch-Kurve in 3D](https://upload.wikimedia.org/wikipedia/commons/thumb/3/39/Koch_Curve_in_Three_Dimensions_%28%22Delta%22_fractal%29.jpg/480px-Koch_Curve_in_Three_Dimensions_%28%22Delta%22_fractal%29.jpg)
([Eric Baird](https://commons.wikimedia.org/wiki/File:Koch_Curve_in_Three_Dimensions_%28%22Delta%22_fractal%29.jpg)) ([Eric Baird](https://commons.wikimedia.org/wiki/File:Koch_Curve_in_Three_Dimensions_%28%22Delta%22_fractal%29.jpg))
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Klicken Sie dazu oben links auf das Disketten-Icon und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/). ![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Klicken Sie dazu oben links auf das Disketten-Icon und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![Smiley](https://upload.wikimedia.org/wikipedia/commons/3/3e/Cool-smiley.svg) ![Smiley](https://upload.wikimedia.org/wikipedia/commons/3/3e/Cool-smiley.svg)
Herzlichen Glückwunsch! Sie haben das 5. Kapitel geschafft. Weiter geht es in [6: Ertragreiche Funktionen](seminar06.ipynb). Herzlichen Glückwunsch! Sie haben das 5. Kapitel geschafft. Weiter geht es in [6: Ertragreiche Funktionen](seminar06.ipynb).
......
notebooks/seminar07.ipynb
+ 32
− 59
View file @ ad7bc970
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
# Seminar Problemorientierte Programmierung # Seminar Problemorientierte Programmierung
## 7 Iteration ## 7 Iteration
[Chapter 7: Iteration](http://greenteapress.com/thinkpython2/html/thinkpython2008.html) [Chapter 7: Iteration](http://greenteapress.com/thinkpython2/html/thinkpython2008.html)
import socket import socket
Dieses Kapitel handelt von der Iteration - der Möglichkeit, eine Folge von Anweisungen zu wiederholen. Wir haben eine Art der Iteration unter Verwendung der Rekursion schon im [Abschnitt 5.8](seminar05.ipynb#5.8-Rekursion) gesehen und eine andere Art, mit Hilfe der `for`-Schleife, in [Abschnitt 4.2](seminar04.ipynb#4.2-Einfache-Wiederholung). In diesem Kapitel lernen wir eine weitere Variante unter Verwendung der `while`-Anweisung kennen. Aber vorher schauen wir uns noch einmal die Zuweisung eines Wertes an eine Variable an. Dieses Kapitel handelt von der Iteration - der Möglichkeit, eine Folge von Anweisungen zu wiederholen. Wir haben eine Art der Iteration unter Verwendung der Rekursion schon im [Abschnitt 5.8](seminar05.ipynb#5.8-Rekursion) gesehen und eine andere Art, mit Hilfe der `for`-Schleife, in [Abschnitt 4.2](seminar04.ipynb#4.2-Einfache-Wiederholung). In diesem Kapitel lernen wir eine weitere Variante unter Verwendung der `while`-Anweisung kennen. Aber vorher schauen wir uns noch einmal die Zuweisung eines Wertes an eine Variable an.
### Ihre Lernziele: ### Ihre Lernziele:
Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text: Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:
- -
- -
- -
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
## Exkurs: Was mir an Python gefällt ## Exkurs: Was mir an Python gefällt
Wir wünschen Ihnen ein frohes Fest und einen guten Rutsch ins neue Jahr. In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.
Mit den Operatoren aus diesem Kapitel können wir ganz leicht das Verfahren zur Umwandlung einer Dezimalzahl in ihre Binärdarstellung implementieren:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
""" # Umwandlung einer positiven, ganzen Dezimalzahl in Binärdarstellung (als Zeichenkette)
Quelle: https://teampython.wordpress.com/2015/12/12/print-a-christmas-tree/ def dez_zu_bin(n):
Python 3 version by antiloquax (2015), based on code from datamungeblog.com. ergebnis = ""
""" while n > 0:
ergebnis = str(n % 2) + ergebnis
from random import choice n = n // 2
from random import random return ergebnis
# If you change this, use an odd number. print(dez_zu_bin(42))
size = 21
# Und weil wir heute beim Thema Rekursion sind ...
# Probability that a character will be green. def dez_zu_bin_rekursiv(n):
prob_gr = 0.6 if n == 0:
# Colour codes. return ""
colours = [31, 33, 34, 35, 36, 37] return dez_zu_bin_rekursiv(n // 2) + str(n % 2)
# Characters to use for decorations. Experiment with these.
# The chr(169) and chr(174) characters may not work in all terminals print(dez_zu_bin_rekursiv(42))
# (extended ASCII, c and r in a circle).
decs = ['@', '&', '*', chr(169), chr(174)] # Warum eigentlich auf ein Zahlensystem festlegen?
def dez_zu_allem(n, s):
# Format string for printing blinking characters. if n == 0:
blink_col = "\033[5;{0}m{1}\033[0m" return ""
# String to print a green octothorpe ('#'). return dez_zu_allem(n // len(s), s) + s[n % len(s)]
leaf = "\033[32m#\033[0m"
print(dez_zu_allem(42, "01"))
# Width of the tree, will grow by 2 each time. print(dez_zu_allem(42, "0123456789"))
width = 1 print(dez_zu_allem(42, "01234567"))
# Initialise the tree string, with a star at the top. print(dez_zu_allem(42, "0123456789ABCDEF"))
tree = "\n{}*\n".format(' ' * (size)) print(dez_zu_allem(42, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
""" Main Loop starts now."""
""" We can't use the normal "format" centering approach:
("{:^nn}".format(string) where "nn" is the width of the line),
with these ansi codes. This is because Python sees the strings as being
more than one character long (15 & 10 for baubles and leaves)."""
# Loop from (size - 1) down to 0, using the counter as the padding size.
for pad in range(size - 1, -1, -1):
# Increase the width of the tree by 2.
width += 2
# Put the characters for the line in "temp".
temp = ""
for j in range(width):
# Make some leaves.
if random() < prob_gr:
temp += leaf
# And also some baubles.
else:
temp += blink_col.format(choice(colours), choice(decs))
# Add that string to the line, with padding.
tree += "{0}{1}\n".format(' ' * pad, temp)
# Add a "trunk" of 2 lines and return.
print(tree + "{0}{1}\n".format(' ' * (size - 1), "000") * 2)
print("\x46\x72\x6f\x68\x65\x20\x46\x65\x73\x74\x74\x61\x67\x65\x21")
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
[Und noch viele weitere schöne Beispiele](https://codegolf.stackexchange.com/questions/15860/) [Und noch viele weitere schöne Beispiele](https://codegolf.stackexchange.com/questions/15860/)
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 7.1 Neuzuweisung ### 7.1 Neuzuweisung
Wie Sie vielleicht schon herausgefunden haben, ist es erlaubt, mehr als nur eine Zuweisung an die selbe Variable durchzuführen. Durch eine neue Zuweisung verweist eine existierende Variable auf einen neuen Wert (und nicht mehr auf den alten Wert). Wie Sie vielleicht schon herausgefunden haben, ist es erlaubt, mehr als nur eine Zuweisung an die selbe Variable durchzuführen. Durch eine neue Zuweisung verweist eine existierende Variable auf einen neuen Wert (und nicht mehr auf den alten Wert).
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
x = 5 x = 5
print(x) print(x)
x = 7 x = 7
print(x) print(x)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Wenn wir `x` beim ersten Mal ausgeben, ist sein Wert 5; beim zweiten Mal ist sein Wert 7. Wenn wir `x` beim ersten Mal ausgeben, ist sein Wert 5; beim zweiten Mal ist sein Wert 7.
Die folgende Abbildung zeigt, wie diese **Neuzuweisung** (*reassignment*) in einem Zustandsdiagramm aussieht: Die folgende Abbildung zeigt, wie diese **Neuzuweisung** (*reassignment*) in einem Zustandsdiagramm aussieht:
![Neuzuordnung](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/zustandsdiagram_x57.svg) ![Neuzuordnung](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/zustandsdiagram_x57.svg)
An dieser Stelle wollen wir auf eine häufige Ursache für Verwechslungen hinweisen: Da Python das Gleichheitszeichen (`=`) für die Zuweisung verwendet, ist es verlockend, eine Anweisung wie `a = b` wie eine mathematische Aussage der Gleichheit zu interpretieren, das heisst, die Behauptung, dass `a` und `b` gleich seien. Aber diese Interpretation ist falsch! An dieser Stelle wollen wir auf eine häufige Ursache für Verwechslungen hinweisen: Da Python das Gleichheitszeichen (`=`) für die Zuweisung verwendet, ist es verlockend, eine Anweisung wie `a = b` wie eine mathematische Aussage der Gleichheit zu interpretieren, das heisst, die Behauptung, dass `a` und `b` gleich seien. Aber diese Interpretation ist falsch!
Zum Einen ist Gleichheit eine symmetrische Beziehung und die Zuweisung ist es nicht. Beispielsweise gilt in der Mathematik: wenn $a=7$, dann ist auch $7=a$. Aber in Python ist die Anweisung `a = 7` erlaubt und `7 = a` ist es nicht. Zum Einen ist Gleichheit eine symmetrische Beziehung und die Zuweisung ist es nicht. Beispielsweise gilt in der Mathematik: wenn $a=7$, dann ist auch $7=a$. Aber in Python ist die Anweisung `a = 7` erlaubt und `7 = a` ist es nicht.
Zum Anderen ist in der Mathematik eine Aussage über die Gleichheit entweder wahr oder falsch und gilt durchgängig. Wenn $a = b$ jetzt gilt, dann wird $a$ stets gleich $b$ sein. In Python kann eine Zuweisung zwei Variablen gleich machen, sie müssen aber nicht durchgängig gleich bleiben: Zum Anderen ist in der Mathematik eine Aussage über die Gleichheit entweder wahr oder falsch und gilt durchgängig. Wenn $a = b$ jetzt gilt, dann wird $a$ stets gleich $b$ sein. In Python kann eine Zuweisung zwei Variablen gleich machen, sie müssen aber nicht durchgängig gleich bleiben:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
a = 5 a = 5
b = a # a und b sind jetzt gleich b = a # a und b sind jetzt gleich
a = 3 # a und b sind nicht mehr gleich a = 3 # a und b sind nicht mehr gleich
print(b) print(b)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Die dritte Zeile ändert den Wert von `a`, aber dadurch ändert sich nicht der Wert von `b`, so dass die beiden Variablen nicht mehr gleich sind. Die dritte Zeile ändert den Wert von `a`, aber dadurch ändert sich nicht der Wert von `b`, so dass die beiden Variablen nicht mehr gleich sind.
Variablen neue Werte zuzuweisen ist oft nützlich, aber Sie sollten vorsichtig damit umgehen. Wenn sich die Werte von Variablen häufig ändern, ist der Code schwerer zu lesen und zu debuggen. Variablen neue Werte zuzuweisen ist oft nützlich, aber Sie sollten vorsichtig damit umgehen. Wenn sich die Werte von Variablen häufig ändern, ist der Code schwerer zu lesen und zu debuggen.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 7.2 Variablen aktualisieren ### 7.2 Variablen aktualisieren
Eine übliche Art der Neuzuweisung ist eine **Aktualisierung** (*update*), bei der der neue Wert vom alten Wert abhängt: Eine übliche Art der Neuzuweisung ist eine **Aktualisierung** (*update*), bei der der neue Wert vom alten Wert abhängt:
```python ```python
x = x + 1 x = x + 1
``` ```
Das bedeutet "nimm' den aktuellen Wert von `x`, füge eins hinzu und aktualisiere dann `x` mit dem neuen Wert". Das bedeutet "nimm' den aktuellen Wert von `x`, füge eins hinzu und aktualisiere dann `x` mit dem neuen Wert".
Wenn wir versuchen eine Variable zu aktualisieren, die nicht existiert, erhalten wir einen Fehler, denn Python evaluiert die rechte Seite der Zuweisung bevor es den Wert der Variablen auf der linken Seite zuweist: Wenn wir versuchen eine Variable zu aktualisieren, die nicht existiert, erhalten wir einen Fehler, denn Python evaluiert die rechte Seite der Zuweisung bevor es den Wert der Variablen auf der linken Seite zuweist:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
y = y + 1 y = y + 1
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Bevor wir eine Variable aktualisieren können, müssen wir sie **initialisieren**, typischerweise mittels einer Zuweisung: Bevor wir eine Variable aktualisieren können, müssen wir sie **initialisieren**, typischerweise mittels einer Zuweisung:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
y = 0 y = 0
y = y + 1 y = y + 1
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Das Aktualisieren einer Variable mittels Addition der Zahl 1 wird **inkrementieren** genannt, das Subtrahieren einer 1 **dekrementieren**. Das Aktualisieren einer Variable mittels Addition der Zahl 1 wird **inkrementieren** genannt, das Subtrahieren einer 1 **dekrementieren**.
![Every time you read this mouseover, toggle between interpreting nested footnotes as footnotes on footnotes and interpreting them as exponents (minus one, modulo 6, plus 1).](https://imgs.xkcd.com/comics/footnote_labyrinths_2x.png) ![Every time you read this mouseover, toggle between interpreting nested footnotes as footnotes on footnotes and interpreting them as exponents (minus one, modulo 6, plus 1).](https://imgs.xkcd.com/comics/footnote_labyrinths_2x.png)
[Footnote Labyrinths](https://xkcd.com/1208/), Randall Munroe [Footnote Labyrinths](https://xkcd.com/1208/), Randall Munroe
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 7.3 Die `while`-Anweisung ### 7.3 Die `while`-Anweisung
Computer werden häufig zur Automatisierung sich wiederholender Aufgaben genutzt. Identische oder ähnliche Aufgaben zu wiederholen ohne dabei Fehler zu machen, ist etwas was Computer sehr gut können und Menschen eher schlecht. In einem Computerprogramm wird die Wiederholung auch als **Iteration** bezeichnet. Computer werden häufig zur Automatisierung sich wiederholender Aufgaben genutzt. Identische oder ähnliche Aufgaben zu wiederholen ohne dabei Fehler zu machen, ist etwas was Computer sehr gut können und Menschen eher schlecht. In einem Computerprogramm wird die Wiederholung auch als **Iteration** bezeichnet.
Wir haben bereits zwei Funktionen gesehen, `countdown` und `print_t`, die mit Hilfe einer Rekursion eine Wiederholung durchführen. Da Wiederholung sehr häufig benötigt wird, gibt es in Python Sprachkonstrukte, die das vereinfachen. Eines ist die `for`-Anweisung, die wir in [Abschnitt 4.2](seminar04.ipynb#4.2-Einfache-Wiederholung) kennengelernt haben. Darauf kommen wir später noch einmal zurück. Wir haben bereits zwei Funktionen gesehen, `countdown` und `print_t`, die mit Hilfe einer Rekursion eine Wiederholung durchführen. Da Wiederholung sehr häufig benötigt wird, gibt es in Python Sprachkonstrukte, die das vereinfachen. Eines ist die `for`-Anweisung, die wir in [Abschnitt 4.2](seminar04.ipynb#4.2-Einfache-Wiederholung) kennengelernt haben. Darauf kommen wir später noch einmal zurück.
Eine andere Möglichkeit ist die `while`-Anweisung. Dies ist eine Version von `countdown`, die eine `while`-Schleife verwendet: Eine andere Möglichkeit ist die `while`-Anweisung. Dies ist eine Version von `countdown`, die eine `while`-Schleife verwendet:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def countdown(n): def countdown(n):
while n > 0: while n > 0:
print(n) print(n)
n = n - 1 n = n - 1
print("Abheben!") print("Abheben!")
# probieren Sie die Funktion aus # probieren Sie die Funktion aus
countdown(3) countdown(3)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Wir können die `while`-Anweisung fast so lesen, als wäre es natürliche Sprache: "Solange `n` größer als 0 ist, zeige den Wert von `n` an und dann dekrementiere `n`. Sobald 0 erreicht ist, gib das Wort `Abheben!` aus." Wir können die `while`-Anweisung fast so lesen, als wäre es natürliche Sprache: "Solange `n` größer als 0 ist, zeige den Wert von `n` an und dann dekrementiere `n`. Sobald 0 erreicht ist, gib das Wort `Abheben!` aus."
Der Kontrollfluss der `while`-Schleife etwas formaler ausgedrückt sieht so aus: Der Kontrollfluss der `while`-Schleife etwas formaler ausgedrückt sieht so aus:
1. Bestimme ob die Bedingung wahr oder falsch ist. 1. Bestimme ob die Bedingung wahr oder falsch ist.
2. Wenn die Bedingung unwahr ist, beende die `while`-Schleife und fahre mit der Ausführung der nächsten Anweisung nach der eingerückten Folge von Anweisungen fort. 2. Wenn die Bedingung unwahr ist, beende die `while`-Schleife und fahre mit der Ausführung der nächsten Anweisung nach der eingerückten Folge von Anweisungen fort.
3. Wenn die Bedingung wahr ist, führe die eingerückte Folge von Anweisungen im Schleifenrumpf aus und gehe dann zu Schritt 1 zurück. 3. Wenn die Bedingung wahr ist, führe die eingerückte Folge von Anweisungen im Schleifenrumpf aus und gehe dann zu Schritt 1 zurück.
Diese Art von Kontrollfluss wird Schleife genannt, weil der dritte Schritt wieder zum ersten Schritt springt und damit den Kreis (Schleife) schließt. (Im Englischen Original passt es besser: *This type of flow is called a loop because the third step loops back around to the top*.) Diese Art von Kontrollfluss wird Schleife genannt, weil der dritte Schritt wieder zum ersten Schritt springt und damit den Kreis (Schleife) schließt. (Im Englischen Original passt es besser: *This type of flow is called a loop because the third step loops back around to the top*.)
Der Schleifenrumpf sollte den Wert einer oder mehrerer Variablen ändern, sodass die Bedingung irgendwann einmal unwahr wird und die Schleife beendet wird. Ansonsten wiederholt sich die Schleife für immer, was **Endlosschleife** (*infinite loop*) genannt wird. Der Schleifenrumpf sollte den Wert einer oder mehrerer Variablen ändern, sodass die Bedingung irgendwann einmal unwahr wird und die Schleife beendet wird. Ansonsten wiederholt sich die Schleife für immer, was **Endlosschleife** (*infinite loop*) genannt wird.
![Apple Campus: One Infinite Loop](https://upload.wikimedia.org/wikipedia/commons/thumb/8/84/Apple_Campus_One_Infinite_Loop_Sign.jpg/640px-Apple_Campus_One_Infinite_Loop_Sign.jpg) ![Apple Campus: One Infinite Loop](https://upload.wikimedia.org/wikipedia/commons/thumb/8/84/Apple_Campus_One_Infinite_Loop_Sign.jpg/640px-Apple_Campus_One_Infinite_Loop_Sign.jpg)
[Joe Ravi](https://commons.wikimedia.org/wiki/File:Apple_Campus_One_Infinite_Loop_Sign.jpg) [Joe Ravi](https://commons.wikimedia.org/wiki/File:Apple_Campus_One_Infinite_Loop_Sign.jpg)
Im Fall von `countdown` können wir zeigen, dass die Schleife beendet wird: wenn `n` Null oder negativ ist, dann wird die Schleife niemals ausgeführt. Ansonsten wird `n` bei jedem Schleifendurchlauf verringert, so dass wir irgendwann 0 erreichen. Im Fall von `countdown` können wir zeigen, dass die Schleife beendet wird: wenn `n` Null oder negativ ist, dann wird die Schleife niemals ausgeführt. Ansonsten wird `n` bei jedem Schleifendurchlauf verringert, so dass wir irgendwann 0 erreichen.
Bei anderen Schleifen ist das nicht unbedingt so einfach zu sehen, zum Beispiel hier: Bei anderen Schleifen ist das nicht unbedingt so einfach zu sehen, zum Beispiel hier:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def sequence(n): def sequence(n):
while n != 1: while n != 1:
print(n) print(n)
if n % 2 == 0: # n ist gerade if n % 2 == 0: # n ist gerade
n = n // 2 n = n // 2
else: # n ist ungerade else: # n ist ungerade
n = n*3 + 1 n = n*3 + 1
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Die Schleifenbedingung ist hier `n != 1`, daher läuft die Schleife so lange, bis `n` gleich `1` ist, wodurch die Bedingung nicht mehr erfüllt ist. Die Schleifenbedingung ist hier `n != 1`, daher läuft die Schleife so lange, bis `n` gleich `1` ist, wodurch die Bedingung nicht mehr erfüllt ist.
Bei jedem Schleifendurchlauf gibt das Programm den Wert von `n` aus und prüft dann, ob es eine gerade oder eine ungerade Zahl ist. Falls `n` eine gerade Zahl ist, wird `n` durch zwei geteilt. Falls `n` ungerade ist, wird der Wert von `n` ersetzt durch `n*3 + 1`. Übergeben wir der Funktion `sequence` beispielsweise 3 als Argument, dann sind die sich ergebenden Werte von `n` 3, 10, 5, 16, 8, 4, 2, 1. Probieren Sie es selbst für verschiedene Argumente aus: Bei jedem Schleifendurchlauf gibt das Programm den Wert von `n` aus und prüft dann, ob es eine gerade oder eine ungerade Zahl ist. Falls `n` eine gerade Zahl ist, wird `n` durch zwei geteilt. Falls `n` ungerade ist, wird der Wert von `n` ersetzt durch `n*3 + 1`. Übergeben wir der Funktion `sequence` beispielsweise 3 als Argument, dann sind die sich ergebenden Werte von `n` 3, 10, 5, 16, 8, 4, 2, 1. Probieren Sie es selbst für verschiedene Argumente aus:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
sequence(23) sequence(23)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Da `n` manchmal wächst und manchmal schrumpft gibt es keinen offensichtlichen Beweis, dass `n` jemals 1 erreichen wird oder das Programm beendet wird. Für einige bestimmte Werte von `n` können wir zeigen, dass das Programm beendet wird. Wenn beispielsweise der Startwert eine Potenz von 2 ist (2, 4, 8, 16, 32, ...), dann ist `n` bei jedem Schleifendurchlauf eine gerade Zahl (und wird daher halbiert) bis die Schleife den Wert 1 erreicht. Das eben genannte Beispiel endet mit einer solchen Folge, die mir der Zahl 16 beginnt. Da `n` manchmal wächst und manchmal schrumpft gibt es keinen offensichtlichen Beweis, dass `n` jemals 1 erreichen wird oder das Programm beendet wird. Für einige bestimmte Werte von `n` können wir zeigen, dass das Programm beendet wird. Wenn beispielsweise der Startwert eine Potenz von 2 ist (2, 4, 8, 16, 32, ...), dann ist `n` bei jedem Schleifendurchlauf eine gerade Zahl (und wird daher halbiert) bis die Schleife den Wert 1 erreicht. Das eben genannte Beispiel endet mit einer solchen Folge, die mir der Zahl 16 beginnt.
Die schwierige Frage ist, ob wir beweisen können, dass dieses Programm für *jeden* positiven Wert von `n` beendet wird. Bis jetzt hat es noch niemand geschafft, dies zu beweisen. Die schwierige Frage ist, ob wir beweisen können, dass dieses Programm für *jeden* positiven Wert von `n` beendet wird. Bis jetzt hat es noch niemand geschafft, dies zu beweisen.
Es hat aber auch noch niemand geschafft das Gegenteil zu beweisen. [Collatz-Problem](https://de.wikipedia.org/wiki/Collatz-Problem). Es hat aber auch noch niemand geschafft das Gegenteil zu beweisen. [Collatz-Problem](https://de.wikipedia.org/wiki/Collatz-Problem).
![The Strong Collatz Conjecture states that this holds for any set of obsessively-hand-applied rules.](https://imgs.xkcd.com/comics/collatz_conjecture.png) ![The Strong Collatz Conjecture states that this holds for any set of obsessively-hand-applied rules.](https://imgs.xkcd.com/comics/collatz_conjecture.png)
[Collatz Conjecture](https://xkcd.com/710/), Randall Munroe [Collatz Conjecture](https://xkcd.com/710/), Randall Munroe
Schreiben Sie als Übung die Funktion `print_n` aus [Abschnitt 5.8](seminar05.ipynb#5.8-Rekursion) so um, dass eine Schleife statt der Rekursion verwendet wird: Schreiben Sie als Übung die Funktion `print_n` aus [Abschnitt 5.8](seminar05.ipynb#5.8-Rekursion) so um, dass eine Schleife statt der Rekursion verwendet wird:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def print_n(s, n): def print_n(s, n):
# Implementieren Sie hier die Funktion mit Hilfe einer Schleife und ohne Rekursion # Implementieren Sie hier die Funktion mit Hilfe einer Schleife und ohne Rekursion
# Testaufruf # Testaufruf
print_n("hallo", 3) print_n("hallo", 3)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 7.4 `break` ### 7.4 `break`
Manchmal wissen wir nicht, dass es Zeit wird eine Schleife zu beenden, bis wir den Schleifenrumpf bereits zur Hälfte ausgeführt haben. In einem solchen Fall können wir die `break`-Anweisung nutzen, um eine Schleife zu verlassen. Manchmal wissen wir nicht, dass es Zeit wird eine Schleife zu beenden, bis wir den Schleifenrumpf bereits zur Hälfte ausgeführt haben. In einem solchen Fall können wir die `break`-Anweisung nutzen, um eine Schleife zu verlassen.
Nehmen wir beispielsweise an, wir wollen eine Eingabe von der Nutzer_in einlesen bis sie `fertig` eingibt. Dann könnten wir folgendes schreiben: Nehmen wir beispielsweise an, wir wollen eine Eingabe von der Nutzer_in einlesen bis sie `fertig` eingibt. Dann könnten wir folgendes schreiben:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
while True: while True:
line = input('> ') line = input('> ')
if line == 'fertig': if line == 'fertig':
break break
print(line) print(line)
print('Fertig!') print('Fertig!')
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Die Schleifenbedingung ist `True`, was stets wahr ist, daher läuft die Schleife so lange, bis die `break`-Anweisung erreicht wird. Die Schleifenbedingung ist `True`, was stets wahr ist, daher läuft die Schleife so lange, bis die `break`-Anweisung erreicht wird.
Bei jedem Durchlauf wird die Nutzer_in aufgefordert, etwas einzugeben. Wenn Sie `fertig` eingibt, dann beendet die `break`-Anweisung die Schleife. Ansonsten gibt das Programm einfach nur aus, was die Nutzer_in eingegeben hat und geht zurück zum Anfang der Schleife. Probieren Sie es selbst einmal aus. Bei jedem Durchlauf wird die Nutzer_in aufgefordert, etwas einzugeben. Wenn Sie `fertig` eingibt, dann beendet die `break`-Anweisung die Schleife. Ansonsten gibt das Programm einfach nur aus, was die Nutzer_in eingegeben hat und geht zurück zum Anfang der Schleife. Probieren Sie es selbst einmal aus.
Diese Art eine `while`-Schleife zu nutzen ist üblich, denn wir können die Bedingung überall innerhalb der Schleife prüfen (nicht nur am Anfang) und wir können die Abbruchbedingung positiv formulieren ("beende die Schleife, wenn folgendes passiert") statt negativ ("fahre fort bis folgendes passiert"). Diese Art eine `while`-Schleife zu nutzen ist üblich, denn wir können die Bedingung überall innerhalb der Schleife prüfen (nicht nur am Anfang) und wir können die Abbruchbedingung positiv formulieren ("beende die Schleife, wenn folgendes passiert") statt negativ ("fahre fort bis folgendes passiert").
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 7.5 Quadratwurzeln ### 7.5 Quadratwurzeln
![They could say "the connection is probably lost," but it's more fun to do naive time-averaging to give you hope that if you wait around for 1,163 hours, it will finally finish.](https://imgs.xkcd.com/comics/estimation.png) ![They could say "the connection is probably lost," but it's more fun to do naive time-averaging to give you hope that if you wait around for 1,163 hours, it will finally finish.](https://imgs.xkcd.com/comics/estimation.png)
[Estimation](https://xkcd.com/612/), Randall Munroe [Estimation](https://xkcd.com/612/), Randall Munroe
Schleifen werden häufig in Programmen genutzt, die numerische Werte berechnen, indem sie mit einem Näherungswert beginnen und diesen iterativ verbessern. Schleifen werden häufig in Programmen genutzt, die numerische Werte berechnen, indem sie mit einem Näherungswert beginnen und diesen iterativ verbessern.
Beispielsweise kann die Quadratwurzel einer Zahl mit dem [Newton-Verfahren](https://de.wikipedia.org/wiki/Newton-Verfahren) berechnet werden. Angenommen, wir wollen die Quadratwurzel von $a$ berechnen. Wenn wir mit einem (fast beliebigen) Näherungswert $x$ beginnen, können wir einen besseren Näherungswert $y$ mit der folgenden Formel berechnen: Beispielsweise kann die Quadratwurzel einer Zahl mit dem [Newton-Verfahren](https://de.wikipedia.org/wiki/Newton-Verfahren) berechnet werden. Angenommen, wir wollen die Quadratwurzel von $a$ berechnen. Wenn wir mit einem (fast beliebigen) Näherungswert $x$ beginnen, können wir einen besseren Näherungswert $y$ mit der folgenden Formel berechnen:
\begin{equation} \begin{equation}
y = \frac{x + a/x}{2} y = \frac{x + a/x}{2}
\end{equation} \end{equation}
Wenn beispielsweise $a$ gleich 4 ist und $x$ gleich 3: Wenn beispielsweise $a$ gleich 4 ist und $x$ gleich 3:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
a = 4 a = 4
x = 3 x = 3
y = (x + a/x) / 2 y = (x + a/x) / 2
y y
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Das Ergebnis ist näher an der richtigen Antwort ($\sqrt{4} = 2$). Wenn wir den Vorgang mit dem neuen Näherungswert wiederholen, kommen wir noch näher heran: Das Ergebnis ist näher an der richtigen Antwort ($\sqrt{4} = 2$). Wenn wir den Vorgang mit dem neuen Näherungswert wiederholen, kommen wir noch näher heran:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
x = y x = y
y = (x + a/x) / 2 y = (x + a/x) / 2
y y
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Nach ein paar mehr Aktualisierungen ist die Näherung fast exakt: Nach ein paar mehr Aktualisierungen ist die Näherung fast exakt:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
x = y x = y
y = (x + a/x) / 2 y = (x + a/x) / 2
y y
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
x = y x = y
y = (x + a/x) / 2 y = (x + a/x) / 2
y y
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Im Allgemeinen wissen wir anfangs nicht, wie viele Schritte nötig sind, um die richtige Antwort zu erhalten, aber wir wissen es, wenn sich der Näherungswert nicht mehr verändert: Im Allgemeinen wissen wir anfangs nicht, wie viele Schritte nötig sind, um die richtige Antwort zu erhalten, aber wir wissen es, wenn sich der Näherungswert nicht mehr verändert:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
x = y x = y
y = (x + a/x) / 2 y = (x + a/x) / 2
y y
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
x = y x = y
y = (x + a/x) / 2 y = (x + a/x) / 2
y y
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Sobald `x == y` gilt, können wir abbrechen. Im Folgenden eine Schleife, die mit einem Näherungswert `x` beginnt und diesen verbessert, bis er sich nicht mehr ändert: Sobald `x == y` gilt, können wir abbrechen. Im Folgenden eine Schleife, die mit einem Näherungswert `x` beginnt und diesen verbessert, bis er sich nicht mehr ändert:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
a = 4 a = 4
x = 3 x = 3
while True: while True:
print(x) print(x)
y = (x + a/x) / 2 y = (x + a/x) / 2
if y == x: if y == x:
break break
x = y x = y
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Für die meisten Werte von `a` funktioniert das sehr gut aber im Allgemeinen ist es gefährlich, die Gleichheit von Gleitkommazahlen zu testen. Gleitkommazahlen sind nur ungefähr exakt: die meisten rationalen Zahlen wie z.B. 1/3 und irrationale Zahlen wie z.B. $\sqrt{2}$ können nicht exakt als Gleitkommazahl repräsentiert werden. Für die meisten Werte von `a` funktioniert das sehr gut aber im Allgemeinen ist es gefährlich, die Gleichheit von Gleitkommazahlen zu testen. Gleitkommazahlen sind nur ungefähr exakt: die meisten rationalen Zahlen wie z.B. 1/3 und irrationale Zahlen wie z.B. $\sqrt{2}$ können nicht exakt als Gleitkommazahl repräsentiert werden.
Statt zu prüfen ob `x` und `y` exakt gleich sind ist es sicherer, die eingebaute Funktion `abs` zu nutzen, um den Absolutbetrag des Unterschieds zwischen den beiden Zahlen zu berechnen: Statt zu prüfen ob `x` und `y` exakt gleich sind ist es sicherer, die eingebaute Funktion `abs` zu nutzen, um den Absolutbetrag des Unterschieds zwischen den beiden Zahlen zu berechnen:
```python ```python
if abs(y-x) < epsilon: if abs(y-x) < epsilon:
break break
``` ```
Wobei wir für `epsilon` einen sehr kleinen Wert wie z.B. `0.0000001` wählen sollten, der bestimmt, welche Näherung gut genug für uns ist. Wobei wir für `epsilon` einen sehr kleinen Wert wie z.B. `0.0000001` wählen sollten, der bestimmt, welche Näherung gut genug für uns ist.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 7.6 Algorithmen ### 7.6 Algorithmen
![There was a schism in 2007, when a sect advocating OpenOffice created a fork of Sunday.xlsx and maintained it independently for several months. The efforts to reconcile the conflicting schedules led to the reinvention, within the cells of the spreadsheet, of modern version control.](https://imgs.xkcd.com/comics/algorithms.png) ![There was a schism in 2007, when a sect advocating OpenOffice created a fork of Sunday.xlsx and maintained it independently for several months. The efforts to reconcile the conflicting schedules led to the reinvention, within the cells of the spreadsheet, of modern version control.](https://imgs.xkcd.com/comics/algorithms.png)
[Algorithms](https://xkcd.com/1667/), Randall Munroe [Algorithms](https://xkcd.com/1667/), Randall Munroe
Das Newton-Verfahren ist ein klassisches Beispiel für einen **Algorithmus**: ein Prozess zur Lösung einer bestimmten Problemklasse (in diesem Fall die Berechnung von Quadratwurzeln). Das Newton-Verfahren ist ein klassisches Beispiel für einen **Algorithmus**: ein Prozess zur Lösung einer bestimmten Problemklasse (in diesem Fall die Berechnung von Quadratwurzeln).
Um zu verstehen, was ein Algorithmus ist, hilft es vielleicht, sich etwas anzuschauen, was kein Algorithmus ist. Als Sie (wohl in der Grundschule) gelernt haben, Zahlen mit nur einer Ziffer zu multiplizieren, haben Sie wahrscheinlich die Multiplikationstabelle (das [Kleine Einmaleins](https://de.wikipedia.org/wiki/Einmaleins)) auswendig gelernt. Effektiv haben Sie sich damit also 100 verschiedene Lösungen gemerkt. Diese Art von Wissen ist nicht algorithmisch. Um zu verstehen, was ein Algorithmus ist, hilft es vielleicht, sich etwas anzuschauen, was kein Algorithmus ist. Als Sie (wohl in der Grundschule) gelernt haben, Zahlen mit nur einer Ziffer zu multiplizieren, haben Sie wahrscheinlich die Multiplikationstabelle (das [Kleine Einmaleins](https://de.wikipedia.org/wiki/Einmaleins)) auswendig gelernt. Effektiv haben Sie sich damit also 100 verschiedene Lösungen gemerkt. Diese Art von Wissen ist nicht algorithmisch.
Aber wenn Sie "faul" waren, haben Sie vielleicht ein paar Tricks gelernt. Beispielsweise kann man das Produkt einer Zahl $n$ mit 9 berechnen, indem man $n-1$ als erste Ziffer des Ergebnisses aufschreibt und dann $10-n$ als zweite Ziffer anhängt. Dieser Trick ist eine allgemeine Lösung, um jede Zahl mit nur einer Ziffer mit 9 zu multiplizieren. Das ist ein Algorithmus! Aber wenn Sie "faul" waren, haben Sie vielleicht ein paar Tricks gelernt. Beispielsweise kann man das Produkt einer Zahl $n$ mit 9 berechnen, indem man $n-1$ als erste Ziffer des Ergebnisses aufschreibt und dann $10-n$ als zweite Ziffer anhängt. Dieser Trick ist eine allgemeine Lösung, um jede Zahl mit nur einer Ziffer mit 9 zu multiplizieren. Das ist ein Algorithmus!
Genauso sind die Verfahren zur schriftlichen Addition (mit Übertrag), Subtraktion und Division Algorithmen. Eine Eigenschaft von Algorithmen ist, dass Sie keine Intelligenz benötigen, um ausgeführt zu werden. Sie sind mechanische Prozesse bei denen jeder Schritt auf den vorherigen mittels einfacher und eindeutiger Regeln folgt. Genauso sind die Verfahren zur schriftlichen Addition (mit Übertrag), Subtraktion und Division Algorithmen. Eine Eigenschaft von Algorithmen ist, dass Sie keine Intelligenz benötigen, um ausgeführt zu werden. Sie sind mechanische Prozesse bei denen jeder Schritt auf den vorherigen mittels einfacher und eindeutiger Regeln folgt.
Algorithmen auszuführen ist langweilig aber sie zu entwerfen ist interessant, intellektuell herausfordernd und ein wesentlicher Teil der Informatik. Algorithmen auszuführen ist langweilig aber sie zu entwerfen ist interessant, intellektuell herausfordernd und ein wesentlicher Teil der Informatik.
Einige Dinge die Menschen natürlicherweise tun - ohne Schwierigkeiten oder bewusst einen Gedanken daran zu verschwenden - gehören zu den am schwersten repräsentierbaren Algorithmen. Sprachverstehen ist ein gutes Beispiel. Wir alle machen das ständig aber noch niemand konnte richtig erklären *wie* wir das machen - zumindest nicht in Form eines Algorithmus. Einige Dinge die Menschen natürlicherweise tun - ohne Schwierigkeiten oder bewusst einen Gedanken daran zu verschwenden - gehören zu den am schwersten repräsentierbaren Algorithmen. Sprachverstehen ist ein gutes Beispiel. Wir alle machen das ständig aber noch niemand konnte richtig erklären *wie* wir das machen - zumindest nicht in Form eines Algorithmus.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 7.7 Debugging ### 7.7 Debugging
Sobald Sie größere Programme schreiben werden Sie bemerken, dass Sie mehr Zeit mit Debuggen verbringen. Mehr Programmcode bedeutet halt auch, dass es mehr Möglichkeiten gibt, einen Fehler zu machen und mehr Stellen, an denen sich "Bugs" verstecken können. Sobald Sie größere Programme schreiben werden Sie bemerken, dass Sie mehr Zeit mit Debuggen verbringen. Mehr Programmcode bedeutet halt auch, dass es mehr Möglichkeiten gibt, einen Fehler zu machen und mehr Stellen, an denen sich "Bugs" verstecken können.
Eine Möglichkeit die Zeit für das Debuggen zu reduzieren ist "Debugging durch Halbieren" (denken Sie an die binäre Suche). Wenn Ihr Programm beispielsweise 100 Zeilen hat und Sie jede Zeile einzeln prüfen würden, dann bräuchten Sie 100 Schritte zum Debuggen. Eine Möglichkeit die Zeit für das Debuggen zu reduzieren ist "Debugging durch Halbieren" (denken Sie an die binäre Suche). Wenn Ihr Programm beispielsweise 100 Zeilen hat und Sie jede Zeile einzeln prüfen würden, dann bräuchten Sie 100 Schritte zum Debuggen.
Stattdessen können Sie versuchen, das Problem zu halbieren. Gehen Sie (ungefähr) zur Hälfte des Programms und suchen Sie dort nach einem Zwischenwert (eine Variable), den Sie überprüfen können. Fügen Sie eine `print`-Anweisung, die den Zwischenwert ausgibt (oder etwas anderes, was einen prüfbare Auswirkung hat), hinzu und starten Sie das Programm. Stattdessen können Sie versuchen, das Problem zu halbieren. Gehen Sie (ungefähr) zur Hälfte des Programms und suchen Sie dort nach einem Zwischenwert (eine Variable), den Sie überprüfen können. Fügen Sie eine `print`-Anweisung, die den Zwischenwert ausgibt (oder etwas anderes, was einen prüfbare Auswirkung hat), hinzu und starten Sie das Programm.
Wenn diese Überprüfung in der Mitte das falsche Ergebnis ausgibt, muss das Problem in der ersten Hälfte des Programms liegen, ansonsten in der zweiten Hälfte. Wenn diese Überprüfung in der Mitte das falsche Ergebnis ausgibt, muss das Problem in der ersten Hälfte des Programms liegen, ansonsten in der zweiten Hälfte.
Jedes Mal wenn Sie einen solchen Test durchführen, haben Sie die Anzahl an Codezeilen halbiert, die Sie prüfen müssen. Nach sechs Schritten (was deutlich weniger als 100 ist), sind Sie bei ein oder zwei Programmzeilen angekommen, in denen der Fehler stecken sollte - zumindest theoretisch. Jedes Mal wenn Sie einen solchen Test durchführen, haben Sie die Anzahl an Codezeilen halbiert, die Sie prüfen müssen. Nach sechs Schritten (was deutlich weniger als 100 ist), sind Sie bei ein oder zwei Programmzeilen angekommen, in denen der Fehler stecken sollte - zumindest theoretisch.
In der Praxis ist oft nicht klar, was die "Mitte des Programms" ist und es ist nicht immer möglich, dort einen Test hinzuzufügen. Es ist nicht sinnvoll, die Zeilen zu zählen und die exakte Mitte zu finden. Denken Sie stattdessen an Stellen im Programm, die Fehler enthalten könnten und bei denen es einfach ist, eine Überprüfung (Debug-Ausgabe) hinzuzufügen. Suchen Sie dann nach einer Stelle, bei der Sie denken, dass die Chance, dass der Fehler davor oder danach ist ungefähr gleich ist. In der Praxis ist oft nicht klar, was die "Mitte des Programms" ist und es ist nicht immer möglich, dort einen Test hinzuzufügen. Es ist nicht sinnvoll, die Zeilen zu zählen und die exakte Mitte zu finden. Denken Sie stattdessen an Stellen im Programm, die Fehler enthalten könnten und bei denen es einfach ist, eine Überprüfung (Debug-Ausgabe) hinzuzufügen. Suchen Sie dann nach einer Stelle, bei der Sie denken, dass die Chance, dass der Fehler davor oder danach ist ungefähr gleich ist.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 7.8 Glossar ### 7.8 Glossar
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 7 gelernt haben: Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 7 gelernt haben:
- Neuzuweisung: - Neuzuweisung:
- Aktualisierung: - Aktualisierung:
- Initialisierung: Das Erstellen einer Variablen und die damit verbundene erste Zuweisung eines Wertes - Initialisierung: Das Erstellen einer Variablen und die damit verbundene erste Zuweisung eines Wertes
- inkrementieren: - inkrementieren:
- dekrementieren: - dekrementieren:
- Iteration: - Iteration:
- Endlosschleife: - Endlosschleife:
- Algorithmus: - Algorithmus:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit. Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### 7.9 Übung ### 7.9 Übung
#### Aufgabe 1 #### Aufgabe 1
Kopieren Sie die Schleife aus [Abschnitt 7.5](#7.5-Quadratwurzeln) und verkapseln Sie sie in eine Funktion `mysqrt` die einen Parameter `a` erwartet, einen sinnvollen Wert für `x` wählt und eine Näherung für die Quadratwurzel von `a` zurückliefert. Kopieren Sie die Schleife aus [Abschnitt 7.5](#7.5-Quadratwurzeln) und verkapseln Sie sie in eine Funktion `mysqrt` die einen Parameter `a` erwartet, einen sinnvollen Wert für `x` wählt und eine Näherung für die Quadratwurzel von `a` zurückliefert.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
# Implementieren Sie hier die Funktion mysqrt # Implementieren Sie hier die Funktion mysqrt
# Testen Sie hier die Funktion # Testen Sie hier die Funktion
print("Die Wurzel von 2 ist ungefähr ", mysqrt(2)) print("Die Wurzel von 2 ist ungefähr ", mysqrt(2))
print("Die Wurzel von 23 ist ungefähr ", mysqrt(23)) print("Die Wurzel von 23 ist ungefähr ", mysqrt(23))
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Testen Sie die Funktion, indem Sie eine Funktion `test_square_root` schreiben, die eine Tabelle der folgenden Art ausgibt: Testen Sie die Funktion, indem Sie eine Funktion `test_square_root` schreiben, die eine Tabelle der folgenden Art ausgibt:
``` ```
a mysqrt(a) math.sqrt(a) diff a mysqrt(a) math.sqrt(a) diff
- --------- ------------ ---- - --------- ------------ ----
1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0
2.0 1.41421356237 1.41421356237 2.22044604925e-16 2.0 1.41421356237 1.41421356237 2.22044604925e-16
3.0 1.73205080757 1.73205080757 0.0 3.0 1.73205080757 1.73205080757 0.0
4.0 2.0 2.0 0.0 4.0 2.0 2.0 0.0
5.0 2.2360679775 2.2360679775 0.0 5.0 2.2360679775 2.2360679775 0.0
6.0 2.44948974278 2.44948974278 0.0 6.0 2.44948974278 2.44948974278 0.0
7.0 2.64575131106 2.64575131106 0.0 7.0 2.64575131106 2.64575131106 0.0
8.0 2.82842712475 2.82842712475 4.4408920985e-16 8.0 2.82842712475 2.82842712475 4.4408920985e-16
9.0 3.0 3.0 0.0 9.0 3.0 3.0 0.0
``` ```
Dabei ist die erste Spalte eine Zahl, `a`; die zweite Spalte ist die Quadratwurzel von `a` die mit `mysqrt` berechnet wurde; die dritte Spalte ist die Quadratwurzel, die mittels `math.sqrt` berechnet wurde; und die vierte Spalte ist der Absolutbetrag des Unterschieds zwischen den beiden Werten. Dabei ist die erste Spalte eine Zahl, `a`; die zweite Spalte ist die Quadratwurzel von `a` die mit `mysqrt` berechnet wurde; die dritte Spalte ist die Quadratwurzel, die mittels `math.sqrt` berechnet wurde; und die vierte Spalte ist der Absolutbetrag des Unterschieds zwischen den beiden Werten.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def test_square_root(): def test_square_root():
# Implementieren Sie hier die Funktion test_square_root # Implementieren Sie hier die Funktion test_square_root
# Rufen Sie hier die Funktion test_square_root auf # Rufen Sie hier die Funktion test_square_root auf
test_square_root() test_square_root()
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![If only we&#39;d chosen 1944-12-02 08:45:52 as the Unix epoch, we could&#39;ve combined two doomsday scenarios into one and added a really boring scene to that Roland Emmerich movie.](https://imgs.xkcd.com/comics/2038.png) ![If only we&#39;d chosen 1944-12-02 08:45:52 as the Unix epoch, we could&#39;ve combined two doomsday scenarios into one and added a really boring scene to that Roland Emmerich movie.](https://imgs.xkcd.com/comics/2038.png)
([2038](https://xkcd.com/607/), Randall Munroe) ([2038](https://xkcd.com/607/), Randall Munroe)
![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png) ![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png)
([Spoiler Alert](https://xkcd.com/109/), Randall Munroe) ([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)
1. Schreiben Sie den Kopf der Funktion, überlegen Sie welche Argumente der Funktion übergeben müssen. 1. Schreiben Sie den Kopf der Funktion, überlegen Sie welche Argumente der Funktion übergeben müssen.
2. Kopieren Sie, wie oben bereits erwähnt die Funktion. 2. Kopieren Sie, wie oben bereits erwähnt die Funktion.
3. Wenn Sie das Notebook aufmerksam gelesen haben, werden Sie sich an einige Verbesserungen erinnern, die wir vornehmen müssen. 3. Wenn Sie das Notebook aufmerksam gelesen haben, werden Sie sich an einige Verbesserungen erinnern, die wir vornehmen müssen.
4. Vor allem heißt das x und y mit der `abs()`-Funktion zu vergleichen, also zu schreiben `abs(x-y)<epsilon` wobei Sie einen Wert für epsilon wählen müssen, der klein genug ist. Fügen Sie diese Änderungen in Ihren Code ein. 4. Vor allem heißt das x und y mit der `abs()`-Funktion zu vergleichen, also zu schreiben `abs(x-y)<epsilon` wobei Sie einen Wert für epsilon wählen müssen, der klein genug ist. Fügen Sie diese Änderungen in Ihren Code ein.
5. Wählen Sie einen geeigneten Wert für x in Abhängigkeit von a. Da fast jeder Wert funktioniert, können Sie ihn frei wählen, sie müssen lediglich sicherstellen, dass x ungleich null ist. 5. Wählen Sie einen geeigneten Wert für x in Abhängigkeit von a. Da fast jeder Wert funktioniert, können Sie ihn frei wählen, sie müssen lediglich sicherstellen, dass x ungleich null ist.
6. Vergessen Sie nicht Ihre Funktion mit Werten zu testen, die Sie überprüfen können. 6. Vergessen Sie nicht Ihre Funktion mit Werten zu testen, die Sie überprüfen können.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def mysqrt(a): def mysqrt(a):
if a==1: if a==1:
x=a x=a
else: else:
x=a-1 x=a-1
epsilon=0.00000000001 epsilon=0.00000000001
while True: while True:
y=(x+a/x)/2 y=(x+a/x)/2
if abs(y-x) < epsilon: if abs(y-x) < epsilon:
break break
x=y x=y
return x return x
mysqrt(25) mysqrt(25)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Wenn die von Ihnen geschriebene Funktion richtig funktiniert, können Sie an der gewünschten Vergleichstabelle arbeiten. Dazu können Sie folgendermaßen ansetzen: Wenn die von Ihnen geschriebene Funktion richtig funktiniert, können Sie an der gewünschten Vergleichstabelle arbeiten. Dazu können Sie folgendermaßen ansetzen:
1. Der Kopf der Funktion ist bereits gegeben, aber Sie können bereits den Tabellenkopf schreiben. Dafür schreiben Sie eine `print`-Anweisung für jede Zeile des Tabellenkopfs. 1. Der Kopf der Funktion ist bereits gegeben, aber Sie können bereits den Tabellenkopf schreiben. Dafür schreiben Sie eine `print`-Anweisung für jede Zeile des Tabellenkopfs.
2. Als nächstes müssen Sie entscheiden ob Sie die Tabelle von oben ausgeben wollen, dann muss a die Werte 1 bis 9 annehmen - Sie brauchen eine Schleife - oder ob Sie die Tabelle für ein beliebiges a berechnen wollen, dann müssen Sie User-Input einrichten. 2. Als nächstes müssen Sie entscheiden ob Sie die Tabelle von oben ausgeben wollen, dann muss a die Werte 1 bis 9 annehmen - Sie brauchen eine Schleife - oder ob Sie die Tabelle für ein beliebiges a berechnen wollen, dann müssen Sie User-Input einrichten.
3. Wir planen für die Schleife, für diesen Fall können Sie eine `While` oder eine `For` Schleife verwenden. 3. Wir planen für die Schleife, für diesen Fall können Sie eine `While` oder eine `For` Schleife verwenden.
4. Prüfen Sie zunächst ob beide Funktionen Werte zurückgeben. Dies ist für die Pythonfunktion der Fall, trifft es auch auf Ihre Funktion zu? Wenn nicht ergänzen Sie die `return`-Anweisung an geeigneter Stelle. 4. Prüfen Sie zunächst ob beide Funktionen Werte zurückgeben. Dies ist für die Pythonfunktion der Fall, trifft es auch auf Ihre Funktion zu? Wenn nicht ergänzen Sie die `return`-Anweisung an geeigneter Stelle.
5. Weißen Sie die beiden Funktionen und damit ihre Rückgabewerte neuen Funktionen zu. 5. Weißen Sie die beiden Funktionen und damit ihre Rückgabewerte neuen Funktionen zu.
6. Berechnen Sie die Differenz zwischen `mysqrt()` und `math.sqrt()` und speichern Sie diese in einer neuen Variablen 6. Berechnen Sie die Differenz zwischen `mysqrt()` und `math.sqrt()` und speichern Sie diese in einer neuen Variablen
7. Für ein nachvollziehbares `a` testen Sie jetzt einmal die 3 Ausgaben. 7. Für ein nachvollziehbares `a` testen Sie jetzt einmal die 3 Ausgaben.
8. Fügen Sie die `print` Anweisung hinzu, die die einzelnen Tabellenzeilen ausgibt. 8. Fügen Sie die `print` Anweisung hinzu, die die einzelnen Tabellenzeilen ausgibt.
9. Vergessen Sie nicht den Wert für a bei jedem Schleifendurchlauf zu erhöhen. 9. Vergessen Sie nicht den Wert für a bei jedem Schleifendurchlauf zu erhöhen.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
import math import math
def test_square_root(): def test_square_root():
a=1.0 a=1.0
print('a mysqrt(a) math.sqrt(a) diff') print('a mysqrt(a) math.sqrt(a) diff')
print('- --------- ------------ ----') print('- --------- ------------ ----')
while a<10: while a<10:
E= mysqrt(a) E= mysqrt(a)
M= math.sqrt(a) M= math.sqrt(a)
if E<M: if E<M:
diff=M-E diff=M-E
else: else:
diff=E-M diff=E-M
E=str(E) E=str(E)
M=str(M) M=str(M)
print(a,E,(18-len(E))*' ',M,(18-len(M))*' ',diff) print(a,E,(18-len(E))*' ',M,(18-len(M))*' ',diff)
a=a+1 a=a+1
test_square_root() test_square_root()
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### Aufgabe 2 ### Aufgabe 2
Die eingebaute Funktion `eval` erwartet eine Zeichenkette und führt sie dann mit dem Python-Interpreter aus. Beispielsweise: Die eingebaute Funktion `eval` erwartet eine Zeichenkette und führt sie dann mit dem Python-Interpreter aus. Beispielsweise:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
eval('1 + 2 * 3') eval('1 + 2 * 3')
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
import math import math
eval('math.sqrt(5)') eval('math.sqrt(5)')
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
eval('type(math.pi)') eval('type(math.pi)')
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Schreiben Sie eine Funktion `eval_loop`, die den Nutzer iterativ bittet etwas einzugeben, die eingegebene Zeichenkette mittels `eval` ausführt und schließlich das Ergebnis ausgibt. Schreiben Sie eine Funktion `eval_loop`, die den Nutzer iterativ bittet etwas einzugeben, die eingegebene Zeichenkette mittels `eval` ausführt und schließlich das Ergebnis ausgibt.
Die Funktion sollte so lange laufen, bis der Nutzer `fertig` eingibt und dann sollte der Rückgabewert des letzten ausgeführten Ausdrucks ausgegeben werden. Die Funktion sollte so lange laufen, bis der Nutzer `fertig` eingibt und dann sollte der Rückgabewert des letzten ausgeführten Ausdrucks ausgegeben werden.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
# Implementieren Sie hier die Funktion eval_loop # Implementieren Sie hier die Funktion eval_loop
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png) ![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png)
([Spoiler Alert](https://xkcd.com/109/), Randall Munroe) ([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)
1. Schreiben Sie den Funktionskopf 1. Schreiben Sie den Funktionskopf
2. Richten Sie die Nutzereingabe ein und weißen Sie diese einer Variablen zu, damit wir den Input weiter verwenden können. 2. Richten Sie die Nutzereingabe ein und weißen Sie diese einer Variablen zu, damit wir den Input weiter verwenden können.
3. Da der Nutzer mehrfach eine Eingabe machen soll, muss diese Zuweißung innerhalb einer Schleife stattfinden. 3. Da der Nutzer mehrfach eine Eingabe machen soll, muss diese Zuweißung innerhalb einer Schleife stattfinden.
4. Überlegen Sie welche Schleife Sie verwenden müssen, was ist hier Ihre Abbruchbedingung? Ist Sie positiv oder negativ? 4. Überlegen Sie welche Schleife Sie verwenden müssen, was ist hier Ihre Abbruchbedingung? Ist Sie positiv oder negativ?
5. Wenn `fertig` eingegeben wird, soll der letzte berechnete Wert zurückgegeben werden, daher muss dieser in einer Variablen temporär gespeichert werden. 5. Wenn `fertig` eingegeben wird, soll der letzte berechnete Wert zurückgegeben werden, daher muss dieser in einer Variablen temporär gespeichert werden.
6. Wenn nicht `fertig` eingegeben wird, wird der neue Ausdruck evaluiert und der Wert der zuvor in der temporären Variablen gespeichert war überschrieben. 6. Wenn nicht `fertig` eingegeben wird, wird der neue Ausdruck evaluiert und der Wert der zuvor in der temporären Variablen gespeichert war überschrieben.
7. Vergessen Sie nicht, dass die temporäre Variable initialisiert werden muss, bevor wir sie zum Speichern von Werten verwenden können. 7. Vergessen Sie nicht, dass die temporäre Variable initialisiert werden muss, bevor wir sie zum Speichern von Werten verwenden können.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
def eval_loop(): def eval_loop():
Eval=0 Eval=0
while True: while True:
line = input('> ') line = input('> ')
if line == 'fertig': if line == 'fertig':
return(Eval) return(Eval)
break break
Eval=eval(line) Eval=eval(line)
print(Eval) print(Eval)
print('Fertig!') print('Fertig!')
eval_loop() eval_loop()
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### Aufgabe 3 ### Aufgabe 3
![Srinivasa Ramanujan](https://upload.wikimedia.org/wikipedia/commons/c/c1/Srinivasa_Ramanujan_-_OPC_-_1.jpg) ![Srinivasa Ramanujan](https://upload.wikimedia.org/wikipedia/commons/c/c1/Srinivasa_Ramanujan_-_OPC_-_1.jpg)
Der Mathematiker [Srinivasa Ramanujan](https://de.wikipedia.org/wiki/S._Ramanujan) hat eine unendliche Folge gefunden die genutzt werden kann, um eine numerische Näherung für 1/$\pi$ zu berechnen: Der Mathematiker [Srinivasa Ramanujan](https://de.wikipedia.org/wiki/S._Ramanujan) hat eine unendliche Folge gefunden die genutzt werden kann, um eine numerische Näherung für 1/$\pi$ zu berechnen:
\begin{equation} \begin{equation}
\frac{1}{\pi} = \frac{2\sqrt{2}}{9801} \cdot \sum_{k=0}^{\infty} \frac{(4\cdot k)! \cdot (1103+26390 \cdot k)}{(k!)^4 \cdot 396^{4\cdot k}} \frac{1}{\pi} = \frac{2\sqrt{2}}{9801} \cdot \sum_{k=0}^{\infty} \frac{(4\cdot k)! \cdot (1103+26390 \cdot k)}{(k!)^4 \cdot 396^{4\cdot k}}
\end{equation} \end{equation}
(Eventuell ist die Formel [in der Original-Aufgabenstellung](http://greenteapress.com/thinkpython2/html/thinkpython2008.html#hevea_default541) besser zu lesen.) (Eventuell ist die Formel [in der Original-Aufgabenstellung](http://greenteapress.com/thinkpython2/html/thinkpython2008.html#hevea_default541) besser zu lesen.)
Schreiben Sie eine Funktion `estimate_pi` die diese Formel nutzt, um einen Näherungswert für $\pi$ zu berechnen und zurückzugeben. Sie sollten eine `while`-Schleife nutzen, um die Terme der Summe zu solange berechnen, bis der letzte Term kleiner ist als `1e-15` (was die Python-Notation für $10^{-15}$ ist). Sie können Ihr Ergebnis prüfen, indem Sie es mit `math.pi` vergleichen. Schreiben Sie eine Funktion `estimate_pi` die diese Formel nutzt, um einen Näherungswert für $\pi$ zu berechnen und zurückzugeben. Sie sollten eine `while`-Schleife nutzen, um die Terme der Summe zu solange berechnen, bis der letzte Term kleiner ist als `1e-15` (was die Python-Notation für $10^{-15}$ ist). Sie können Ihr Ergebnis prüfen, indem Sie es mit `math.pi` vergleichen.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png) ![Spoiler Alert](https://imgs.xkcd.com/comics/spoiler_alert.png)
([Spoiler Alert](https://xkcd.com/109/), Randall Munroe) ([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)
1. Auf den ersten Blick sieht diese Formel sehr überwältigend aus. Machen Sie sich keine Sorgen, wir können die Formel in ihre einzelnen Bestandteile aufsplitten und diese einzeln berechnen. 1. Auf den ersten Blick sieht diese Formel sehr überwältigend aus. Machen Sie sich keine Sorgen, wir können die Formel in ihre einzelnen Bestandteile aufsplitten und diese einzeln berechnen.
2. Wie Sie sehen können wird in der Formel zweimal eine Fakultät berechnet. Dafür können Sie die Funktion, die Sie in Seminar 6 geschrieben verwenden. 2. Wie Sie sehen können wird in der Formel zweimal eine Fakultät berechnet. Dafür können Sie die Funktion, die Sie in Seminar 6 geschrieben verwenden.
3. Berechnen Sie zuerst die Konstante vor dem Summenzeichen und speichern Sie den Wert in einer Variablen. In unserer Lösung wird diesè Variable `faktor` genannt. 3. Berechnen Sie zuerst die Konstante vor dem Summenzeichen und speichern Sie den Wert in einer Variablen. In unserer Lösung wird diesè Variable `faktor` genannt.
4. Die `while`-Schleife ersetzt das Summenzeichen. Überlegen Sie sich wie Sie die Bedingung formulieren müssen. Die Abbruchbedingung ist `abs(term)<1e-15` 4. Die `while`-Schleife ersetzt das Summenzeichen. Überlegen Sie sich wie Sie die Bedingung formulieren müssen. Die Abbruchbedingung ist `abs(term)<1e-15`
5. Das Summenzeichen berechnet Werte für k=0 aufwärts (unedlich anstrebend), also muss die Schleife k hochzählen. 5. Das Summenzeichen berechnet Werte für k=0 aufwärts (unedlich anstrebend), also muss die Schleife k hochzählen.
6. Alles was hinter dem Summenzeichen steht wird in der Schleife berechnet. 6. Alles was hinter dem Summenzeichen steht wird in der Schleife berechnet.
7. In jedem Durchgang der Schleife werden Zähler (hier `num`) und Nenner (hier `den`) einzeln berechnet und je einer Variablen zugewiesen 7. In jedem Durchgang der Schleife werden Zähler (hier `num`) und Nenner (hier `den`) einzeln berechnet und je einer Variablen zugewiesen
8. Anschließend wird der Wert des Terms im aktuellen Schleifendurchlauf berechnet, indem die Konstante vor dem Summenzeichen mit dem Bruch hinter dem Summenzeichen multipliziert wird. 8. Anschließend wird der Wert des Terms im aktuellen Schleifendurchlauf berechnet, indem die Konstante vor dem Summenzeichen mit dem Bruch hinter dem Summenzeichen multipliziert wird.
9. Dieser Wert wird in jedem Schleifendurchlauf auf das Gesamtergebnis addiert 9. Dieser Wert wird in jedem Schleifendurchlauf auf das Gesamtergebnis addiert
10. Danach wird geprüft ob die Abbruchbedingung erfüllt ist. 10. Danach wird geprüft ob die Abbruchbedingung erfüllt ist.
11. Da diese Formel 1/$\pi$ berechnet, muss 1/ergebnis gerechnet werden um $\pi$ zu erhalten. 11. Da diese Formel 1/$\pi$ berechnet, muss 1/ergebnis gerechnet werden um $\pi$ zu erhalten.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` ```
import math import math
def fakultaet(n): def fakultaet(n):
if not isinstance(n, int): if not isinstance(n, int):
print('Die Fakultät ist nur für ganze Zahlen definiert.') print('Die Fakultät ist nur für ganze Zahlen definiert.')
return None return None
elif n < 0: elif n < 0:
print('Die Fakultät für negative ganze Zahlen ist nicht definiert.') print('Die Fakultät für negative ganze Zahlen ist nicht definiert.')
return None return None
elif n == 0: elif n == 0:
return 1 return 1
else: else:
return n * fakultaet(n-1) return n * fakultaet(n-1)
def estimate_pi(): def estimate_pi():
faktor = 2 * math.sqrt(2) / 9801 faktor = 2 * math.sqrt(2) / 9801
ergebnis = 0 ergebnis = 0
k = 0 k = 0
while True: while True:
num = fakultaet(4*k) * (1103 + 26390*k) num = fakultaet(4*k) * (1103 + 26390*k)
den = fakultaet(k)**4 * 396**(4*k) den = fakultaet(k)**4 * 396**(4*k)
term = faktor * num / den term = faktor * num / den
ergebnis= ergebnis + term ergebnis= ergebnis + term
if abs(term) < 1e-15: if abs(term) < 1e-15:
break break
k =k + 1 k =k + 1
fast_pi= 1/ ergebnis fast_pi= 1/ ergebnis
return fast_pi return fast_pi
print(estimate_pi()) print(estimate_pi())
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Klicken Sie dazu oben links auf das Disketten-Icon und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/). ![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Klicken Sie dazu oben links auf das Disketten-Icon und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
![Smiley](https://upload.wikimedia.org/wikipedia/commons/5/57/Face-wink.svg) ![Smiley](https://upload.wikimedia.org/wikipedia/commons/5/57/Face-wink.svg)
Herzlichen Glückwunsch! Sie haben das 7. Kapitel geschafft. Weiter geht es in [8: Zeichenketten](seminar08.ipynb). Herzlichen Glückwunsch! Sie haben das 7. Kapitel geschafft. Weiter geht es in [8: Zeichenketten](seminar08.ipynb).
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Impressum | Datenschutzerklärung