Skip to content
Snippets Groups Projects
Commit e9d70fe6 authored by Angelina Charleen Eckert's avatar Angelina Charleen Eckert
Browse files

Einleitung verbessert

parent 1e850c7e
Branches working-branch
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
notebooks/hausaufgabe1.ipynb
+ 22
− 17
View file @ e9d70fe6
%% Cell type:markdown id: tags:
<h1>Table of Contents<span class="tocSkip"></span></h1>
<div class="toc"><ul class="toc-item"><li><span><a href="#Aufgabe-1" data-toc-modified-id="Aufgabe-1-1"><span class="toc-item-num">1&nbsp;&nbsp;</span>Aufgabe 1</a></span></li><li><span><a href="#Aufgabe-2" data-toc-modified-id="Aufgabe-2-2"><span class="toc-item-num">2&nbsp;&nbsp;</span>Aufgabe 2</a></span></li><li><span><a href="#Aufgabe-3" data-toc-modified-id="Aufgabe-3-3"><span class="toc-item-num">3&nbsp;&nbsp;</span>Aufgabe 3</a></span></li></ul></div>
<div class="toc"><ul class="toc-item"><li><span><a href="#Aufgabe-1" data-toc-modified-id="Aufgabe-1-1"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 1</a></span></li><li><span><a href="#Aufgabe-2" data-toc-modified-id="Aufgabe-2-2"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 2</a></span></li><li><span><a href="#Aufgabe-3" data-toc-modified-id="Aufgabe-3-3"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 3</a></span></li></ul></div>
%% Cell type:markdown id: tags:
# 1. Hausaufgabe
### Lesen Sie sich die nachfolgenden Hinweise gut durch und folgen Sie den Anweisungen, um Missverständnisse zu vermeiden.
Geben Sie diese Hausaufgabe gemeinsam mit Ihrem/r Partner/in ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei (hausaufgabe1.ipynb) in Moodle hoch. Verwenden Sie Kommentare im Python-Quellcode (#), um ihr Programm zu kommentieren.
Geben Sie diese Hausaufgabe gemeinsam als Pair Programming Gruppe ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei unter `Hausaufgabe 1` in Moodle hoch.
**Tipps und Anmerkungen**:
- Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht. Passen Sie auf, dass Sie in moodle auf Abgabe drücken, damit es nicht nur ein Entwurf ist.
- Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht. Passen Sie auf, dass Sie in Moodle auf Abgabe drücken, damit es nicht nur ein Entwurf ist.
- Nutzen Sie das Wissen aus den bisher bearbeiteten Notebooks (1-3).
- Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!
- Fügen Sie außerdem **kurze Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
- inline-Kommentare (Code kommentieren): `#`
- Docstrings (Beschreibung der Funktion): `''' '''`
- Bitte ändern Sie den Dateinamen ihrer Hausaufgabe zu: **hausaufgabe1_nachnamePartnerIn1_nachnamePartnerIn2.ipynb**
- z.B. `hausaufgabe1_schwab_jaeschke.ipynb`
- z.B. `hausaufgabe1_hachmeier_jäschke.ipynb`
- Das können Sie einfach machen, indem Sie **jetzt** oben links auf `hausaufgabe1` klicken und den neuen Namen eingeben.
- Falls Sie **generative KI** in der Hausaufgabe genutzt haben wie bspw. ChatGPT: Dokumentieren Sie Ihre Nutzung. Geben Sie alle Eingaben an, die Sie in der jeweiligen Aufgabe verwendet haben und beschreiben Sie, welche Änderungen Sie vor Abgabe zur Anpassung an die jeweilige Aufgabe vornehmen mussten.
- Bei (Verständnis-)Fragen können Sie mich **frühzeitig** und nicht am Abend des Abgabetages per E-Mail oder während der Sitzungen erreichen.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
## Aufgabe 1
Was gibt jede der folgenden Anweisungen aus? Erklären Sie jeweils die Ausgabe.
- Welche Funktionen werden genutzt und was machen diese Funktionen? (die `print` -Funktion muss nicht erklärt werden). Achten Sie darauf, in welcher Reihenfolge die Anweisungen ausgeführt werden.
- Was ist die Ausgabe? Geben Sie Wert und Datentyp an.
- Nutzen Sie Kommentare wie im Beispiel beschrieben.
- Nutzen Sie **mehrere Zeilen pro Anweisung, damit Ihre Antwort in die Breite des Codeblocks passt** und man nicht hin- und herscrollen muss. (Sie finden heraus, was ich meine, wenn es passiert ;) )
Beispiel
```
print("a"+"b")
# zwei Zeichenketten werden durch den Operator "+" verkettet
# Ausgabe: "ab", Datentyp: Zeichenkette/string
```
%% Cell type:code id: tags:
```
``` python
print(2 + 3)
#
#
print(2.2 + 3.3)
#
#
```
%% Cell type:code id: tags:
```
``` python
print('2' + '3')
#
#
print('2.2' + '3.3')
#
#
```
%% Cell type:code id: tags:
```
``` python
print(str(2) + str(3))
#
#
print(str(2.2) + str(3.3))
#
#
```
%% Cell type:code id: tags:
```
``` python
print(int('2') + int('3'))
#
#
print(int('2' + '3'))
#
#
```
%% Cell type:code id: tags:
```
``` python
print(float('2') + float('3'))
#
#
print(float('2' + '3'))
#
#
```
%% Cell type:code id: tags:
```
``` python
print(int(2.6 + 2.6))
#
#
print(int(2.6) + int(2.6))
#
#
```
%% Cell type:markdown id: tags:
## Aufgabe 2
**Tipp**: Wichtig bei den folgenden Aufgaben ist der Umgang mit Zeichenketten und der `print`-Funktion. Das haben Sie in den seminar-Notebooks schon gelernt. Gehen Sie diese zu Beginn der Hausaufgabe noch einmal durch und achten Sie, mit welchen **Operatoren** man Zeichenketten zusammenfügen und verketten kann.
### Aufgabe 2a
Ihre Aufgabe ist es, eine Funktion `boxprint` zu implementieren, die eine als Argument übergegebene Zeichenkette innerhalb einer Box ausgibt. Die horizontalen Linien der Box sollen durch `-` erzeugt werden, die vertikalen Linien durch `|` und die Ecken durch `+`. Zwischen der Zeichenkette und dem linken und rechten Rand der Box soll jeweils genau ein Leerzeichen stehen.
Beispiel: Bei Übergabe des Arguments `Hello World!` soll die Funktion folgende Ausgabe erzeugen:
%% Cell type:markdown id: tags:
```
+--------------+
| Hello World! |
+--------------+
```
%% Cell type:markdown id: tags:
Überlegen Sie zunächst, wie Sie das Problem lösen könnten und beschreiben Sie hier kurz ihre Überlegungen bzw. ihr Vorgehen:
-
-
-
%% Cell type:code id: tags:
```
``` python
def boxprint(zeichenkette):
'''Die Funktion nimmt eine Zeichenkette entgegen und gibt
die Zeichenkette innerhalb einer Textbox aus.
'''
pass # Diese Zeile können Sie bei der Implementierung löschen
```
%% Cell type:code id: tags:
```
``` python
# Funktionsaufrufe
boxprint("Hello World!")
boxprint("Das Reh springt hoch, das Reh springt weit. Warum auch nicht, es hat ja Zeit.")
```
%% Cell type:code id: tags:
```
``` python
# Schreiben Sie hier zwei Funktionsaufrufe der Funktion mit eigenen Argumenten
```
%% Cell type:markdown id: tags:
### Aufgabe 2b
Mit dem Linux-Programm [cowsay](https://en.wikipedia.org/wiki/Cowsay) kann man verschiedene Tiere "Sprüche klopfen" lassen:
```
________
< Muuuh! >
--------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||
```
Schreiben Sie eine Funktion `stegosay`, die einen als Argument übergebenen Text folgendermaßen ausgibt:
```
___________________________
( Wo bleibt mein Frühstück? )
---------------------------
o . .
o / `. .' '
o .---. < > < > .---.
o | \ \ - ~ ~ - / / |
_____ ..-~ ~-..-~
| | \~~~\.' `./~~~/
--------- \__/ \__/
.' O \ / / \ '
(_____, `._.' | } \/~~~/
`----. / } | / \__/
`-. | / | / `. ,~~|
~-.__| /_ - ~ ^| /- _ `..-'
| / | / ~-. `-. _ _ _
|_____| |_____| ~ - . _ _ _ _ _>
```
Nutzen Sie dazu Ihre bei der Programmierung von `boxprint` gesammelte Erfahrung. Auch hier soll das Argument eine variable Länge aufweisen können, die "Sprechbox" soll sich anpassen.
**Achung**: Die Denkblase ist verschieden zu der Sprachblase auf Aufgabe 2a.
**Tipp**: Man kann den Stegosaurus im Editiermodus kopieren, Sie müssen nicht jedes Zeichen selbst abtippen.
Durch
```
'''
Dinoabbildung Zeile 1
Dinoabbildung Zeil 2
...
Dinoabbildung Zeile ...
'''
```
können Sie den Dino vollständig im Editormodus dieses Blocks herauskopieren und in Ihre Funktion einfügen.
Freiwillige Erweiterung für Fortgeschrittene: Erweitern Sie die Funktion um ein Argument, mit dem eine maximale Breite (Anzahl Zeichen) übergeben werden kann, so dass die ausgegebene Box nicht breiter ist. Implementieren Sie dann die Behandlung von Zeichenketten, die länger als die vorgegebene Breite sind. Sie haben zwei Möglichkeiten: a) die Zeichenkette abschneiden, b) die Zeichenkette umbrechen. Entscheiden Sie sich für eine der beiden Varianten. Hinweis: auf die ersten `k` Zeichen einer Zeichenkette `s` können Sie mittels `s[0:k]` zugreifen. Analog können Sie auf das 2. bis 4. Zeichen mittels `s[1:4]` zugreifen, usw.
%% Cell type:code id: tags:
```
``` python
print("""
o . .
o / `. .' '
o .---. < > < > .---.
o | \ \ - ~ ~ - / / |
_____ ..-~ ~-..-~
| | \~~~\.' `./~~~/
--------- \__/ \__/
.' O \ / / \ '
(_____, `._.' | } \/~~~/
`----. / } | / \__/
`-. | / | / `. ,~~|
~-.__| /_ - ~ ^| /- _ `..-'
| / | / ~-. `-. _ _ _
|_____| |_____| ~ - . _ _ _ _ _>
""")
```
%% Cell type:code id: tags:
```
``` python
def stegosay(z):
'''Diese Funktion nimmt eine Zeichenkette entgegen und gibt
die Zeichenkette innerhalb einer Denkblase eines Dinos wieder aus.
In dieser Funktion soll der Dinosaurier inklusive der Denkblase ausgegeben werden.
'''
pass # Diese Zeile können Sie bei der Implementierung löschen
```
%% Cell type:code id: tags:
```
``` python
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
stegosay("Wo bleibt mein Frühstück?")
stegosay("Auf einem Baum, da saß ein Specht. Der Baum war hoch, dem Specht war schlecht.")
```
%% Cell type:markdown id: tags:
## Aufgabe 3
### Aufgabe 3a
Schreiben Sie eine Funktion `sinprint`, die die Sinusfunktion (`math.sin`) im Bereich zwischen 0 und 2π um 90° gedreht ausgibt, also ungefähr so:
```
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
```
Hinweise:
- Lösen Sie diese Aufgabe mit Hilfe einer Schleife. Sie kennen die Syntax und Semantik der `while`-Schleife schon aus der Vorlesung. Sie funktioniert in Python genau so, wie sie für den Pseudocode definiert wurde.
- Sie müssen selbst entscheiden, wieviele Werte Sie im verlangten Intervall berechnen. Die Kurve oben wurde z.B. mit einem Rasterabstand von 0.2 berechnet (d.h., für die Werte 0, 0.2, 0.4, 0.6, ..., 6.2). Dies können Sie übernehmen.
- Damit Sie die Funktion `math.sin` nutzen können, müssen Sie anfangs das `math`-Modul importieren.
- Folgende Probleme müssen gelöst werden:
- Umwandeln von Gleitkommazahlen in Ganzzahlen
- Umwandeln von negativen in positive Zahlen
- Nutzen Sie die `print`-Funktion, um die **Sternchen** (*) an verschiedenen Stellen zu zeichnen.
- Falls Sie das Problem nicht lösen können, fragen Sie im Seminar nach. Dort können Sie wertvolle Tipps erhalten.
%% Cell type:code id: tags:
```
``` python
# Beispiel einer einfachen while-Schleife
i = 0
while i < 5:
print(i)
i = i + 1
```
%% Cell type:code id: tags:
```
``` python
import math
def sinprint():
'''Diese Funktion zeichnet eine Sinus-Kurve ohne eine plot-Bibliothek.'''
pass # Diese Zeile können Sie bei der Implementierung löschen
```
%% Cell type:code id: tags:
```
``` python
# Funktionsaufruf
sinprint()
```
%% Cell type:markdown id: tags:
### Aufgabe 3b
Ändern Sie die Funktion `sinprint`, so dass eine beliebige Funktion gezeichnet werden kann. Diese Funktion sollte als Argument übergeben werden können. Also beispielsweise so:
```python
funcprint(math.sin)
```
Ändern Sie gleich auch den Namen der Funktion zu `funcprint`, da sie ja jetzt nicht nur die Sinusfunktion ausgeben kann. (In der 2. Aufgabe des 3. Jupyter-Notebooks haben wir die Funktion `do_twice` kennengelernt - dort sehen Sie, wie Sie Funktionen als Argumente übergeben und verwenden können.)
%% Cell type:code id: tags:
```
``` python
import math
def funcprint(func):
'''Diese Funktion nimmt den Parameter `func` entgegen, der ein Funktionsobjekt repräsentiert und zeichnet
die Funktionskurve
'''
pass # Diese Zeile können Sie bei der Implementierung löschen
```
%% Cell type:code id: tags:
```
``` python
# Funktionsaufruf
funcprint(math.sin)
funcprint(math.cos)
```
%% Cell type:markdown id: tags:
### Aufgabe 3c
Wenn alles geklappt hat, enthält Ihre Funktion jetzt einige Werte, die als Literale angegeben sind, z.B.
- den Anfangs- und Endwert des Intervalls, in dem die Funktion gezeichnet werden soll
- die Schrittweite
- die Verschiebung des Nullpunkts
- Skalierung in Richtung der x-Achse (Stauchung, Streckung)
- Skalierung in Richtung der y-Achse (Stauchung, Streckung)
Erweitern Sie die Funktion `funcprint`, so dass alle diese Werte als Argumente übergeben werden können.
Fangen Sie mit einem Parameter an und versuchen Sie nach und nach alle Parameter einzusetzen. Falls die nicht funktioniert, rufen Sie Ihre Funktion mit den Parametern auf, die funktionieren.
%% Cell type:code id: tags:
```
``` python
import math
def funcprint_advanced(func, start, end, step, shift, scale_y):
'''Diese Funktion nimmt den Parameter `func` entgegen, der ein Funktionsobjekt repräsentiert und zeichnet
die Funktionskurve. Zudem nimmt die Funktion mehrere Parameter entgegen, die die Kurve verändern können.
'''
pass # Diese Zeile können Sie bei der Implementierung löschen
```
%% Cell type:code id: tags:
```
``` python
# Funktionsrauf
funcprint_advanced(math.cos, 2, 10, 0.1, 30, 5)
```
%% Cell type:markdown id: tags:
![Smiley](https://upload.wikimedia.org/wikipedia/commons/0/0f/Face-glasses.svg)
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
......
notebooks/hausaufgabe2.ipynb
+ 40
− 22
View file @ e9d70fe6
%% Cell type:markdown id: tags:
<h1>Table of Contents<span class="tocSkip"></span></h1>
<div class="toc"><ul class="toc-item"><li><span><a href="#Aufgabe-1" data-toc-modified-id="Aufgabe-1-1"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 1</a></span></li><li><span><a href="#Aufgabe-2" data-toc-modified-id="Aufgabe-2-2"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 2</a></span></li><li><span><a href="#Aufgabe-3" data-toc-modified-id="Aufgabe-3-3"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 3</a></span></li><li><span><a href="#Aufgabe-4" data-toc-modified-id="Aufgabe-4-4"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 4</a></span></li><li><span><a href="#Aufgabe-5" data-toc-modified-id="Aufgabe-5-5"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 5</a></span></li><li><span><a href="#Aufgabe-6" data-toc-modified-id="Aufgabe-6-6"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 6</a></span></li></ul></div>
%% Cell type:markdown id: tags:
# 2. Hausaufgabe
Geben Sie diese Hausaufgabe gemeinsam mit Ihrem/r Partner/in ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei (hausaufgabe2_nachname1_nachname2.ipynb) in Moodle hoch. Verwenden Sie Kommentare im Python-Quellcode und Markdown-Textboxen im Jupyter-Notebook ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele)) um ihr Programm zu kommentieren.
### Lesen Sie sich die nachfolgenden Hinweise gut durch und folgen Sie den Anweisungen, um Missverständnisse zu vermeiden.
Geben Sie diese Hausaufgabe gemeinsam als Pair Programming Gruppe ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei unter `Hausaufgabe 2` in Moodle hoch.
* Geben Sie bitte Ihrem **Notebook einen Namen**, sodass es Ihnen und Ihrem Partner zugeordnet werden kann (z.B. *hausaufgabe2_nachname1_nachname2.ipynb*)
* Fügen Sie außerdem **Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
**Tipps und Anmerkungen**:
- Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht. Passen Sie auf, dass Sie in Moodle auf Abgabe drücken, damit es nicht nur ein Entwurf ist.
- Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!
- Fügen Sie außerdem **kurze Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
- inline-Kommentare (Code kommentieren): `#`
- Docstrings (Beschreibung der Funktion): `''' '''`
* In jedem Codeblock steht ein **Funktionsaufruf**, der die von Ihnen definierte Funktion aufruft. Dies sollte funktionieren (dort kann man auch direkt ablesen, wieviele und welche Argumente benötigt werden). Anfangs können Sie den Aufruf gerne auskommentieren, damit nicht ständig eine Fehlermeldung angezeigt wird.
* Schreiben Sie bitte zu jeder definierten Funktion **einen Funktionsaufruf mit eigens definierten *turtle-Objekten* und Parametern**.
* Nutzen Sie **Schleifen** in allen Aufgaben, in denen Sie geometrische Figuren zeichnen müssen (Sie haben diese in den Seminaren kennengelernt)!
* Verwenden Sie die von Ihnen **geschriebenen Funktionen aus vorherigen Aufgabenteilen in den Folgeaufgaben**, um Code zu sparen und Fehler zu vermeiden (zum Beispiel die Nutzung der Funktion `triangle` aus Aufgabe 1 in den Aufgaben 2-5).
* Nutzen Sie Funktionen des turtle-Moduls (siehe https://docs.python.org/3/library/turtle.html).
* Bitte geben Sie nur **eine Lösung pro Aufgabe** ab.
- für Kommentare in Markdown-Textboxen im Jupyter-Notebook: ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele))
- Bitte ändern Sie den Dateinamen ihrer Hausaufgabe zu: **hausaufgabe2_nachnamePartnerIn1_nachnamePartnerIn2.ipynb**
- z.B. `hausaufgabe2_hachmeier_jäschke.ipynb`
- Das können Sie einfach machen, indem Sie **jetzt** oben links auf `hausaufgabe2` klicken und den neuen Namen eingeben.
- Falls Sie **generative KI** in der Hausaufgabe genutzt haben wie bspw. ChatGPT: Dokumentieren Sie Ihre Nutzung. Geben Sie alle Eingaben an, die Sie in der jeweiligen Aufgabe verwendet haben und beschreiben Sie, welche Änderungen Sie vor Abgabe zur Anpassung an die jeweilige Aufgabe vornehmen mussten.
- In jedem Codeblock steht ein **Funktionsaufruf**, der die von Ihnen definierte Funktion aufruft. Dies sollte funktionieren (dort kann man auch direkt ablesen, wieviele und welche Argumente benötigt werden). Anfangs können Sie den Aufruf gerne auskommentieren, damit nicht ständig eine Fehlermeldung angezeigt wird.
- Schreiben Sie bitte zu jeder definierten Funktion **einen Funktionsaufruf mit eigens definierten *turtle-Objekten* und Parametern**.
- Nutzen Sie **Schleifen** in allen Aufgaben, in denen Sie geometrische Figuren zeichnen müssen (Sie haben diese in den Seminaren kennengelernt)!
- Verwenden Sie die von Ihnen **geschriebenen Funktionen aus vorherigen Aufgabenteilen in den Folgeaufgaben**, um Code zu sparen und Fehler zu vermeiden (zum Beispiel die Nutzung der Funktion `triangle` aus Aufgabe 1 in den Aufgaben 2-5).
- Nutzen Sie Funktionen des turtle-Moduls (siehe https://docs.python.org/3/library/turtle.html).
- Bitte geben Sie nur **eine Lösung pro Aufgabe** ab.
- Bei (Verständnis-)Fragen können Sie mich **frühzeitig** und nicht am Abend des Abgabetages per E-Mail oder während der Sitzungen erreichen.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
### Hilfsfunktion:
%% Cell type:code id: tags:
```
``` python
from random import randint
def setcolor():
"""generiert eine zufällige rgb-Farbe"""
return (randint(0,255),randint(0,255),randint(0,255))
```
%% Cell type:code id: tags:
```
``` python
# Beispielcode zur Hilfsfunktion
import turtle
# wichtig ist es, bei Jupyter Notebook die folgende Codezeile anzugeben,
# um mit rgb Farbcodes zu arbeiten.
# In der Sandbox bitte die Zeile weglassen.
turtle.colormode(255)
caro = turtle.Turtle()
for i in range(4):
caro.fd(100)
caro.lt(90)
caro.color(setcolor())
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Tipps für die folgenden Aufgaben:
Nutzen Sie die python-Dokumention von `turtle`: https://docs.python.org/3/library/turtle.html. Dort finden Sie alle Funktionen, die Sie anwenden können. Wichtig für die Hausaufgabe sind (neben denen, die Sie schon kennengelernt haben):
- `t.shape('turtle')`: ändert die Gestalt der "Schildkröte" in eine Schildkröte.
- Die Farbe der Schildkröte und der Färbung der Muster wählt man mit `t.color()`.
- ```t.begin_fill()
...
t.end_fill()```: Färbt das Muster, was die Schildkröte zwischen den beiden Anweisungen gezeichnet hat, ein.
- `t.stamp()`: Platziert bei Aufruf eine Schildkröte an der Stelle, an der die Schildkröte sich zu diesem Zeitpunkt befindet.
- Mit `t.speed()` können Sie der turtle verschiedene Geschwindigkeiten geben.
%% Cell type:markdown id: tags:
## Aufgaben
### Aufgabe 1
Schreiben Sie eine Funktion `triangle`, die zwei Parameter `t` und `l` erwartet. `t` ist ein turtle-Objekt, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um ein gleichseitiges Dreieck mit Seitenlänge `l` zu zeichnen. Schreiben Sie einen Funktionsaufruf, der `otto` und `40` an `triangle` übergibt und rufen Sie ihr Programm auf.
Vervollständigen Sie ihren Code:
- Färben Sie die Schildkröte in einer Farbe Ihrer Wahl.
- Färben Sie Ihr Dreieck in einer Farbe Ihrer Wahl.
- Platzieren Sie an jeder Ecke Ihres Dreiecks eine Schildkröte.
%% Cell type:code id: tags:
```
``` python
import turtle
turtle.colormode(255)
def triangle(t, l):
pass # löschen Sie diese Zeile, wenn Sie anfangen, die Funktion zu implementieren
otto = turtle.Turtle()
triangle(otto, 100)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Aufgabe 2
Schreiben Sie eine Funktion `repeat_triangle`, die `n` gleichseitige Dreiecke nebeneinander zeichnet. Sie soll drei Argumente `t`, `n` und `l` erhalten. `t` ist ein turtle-Objekt, `l` gibt die Seitenlänge der Dreiecke an und `n` die Anzahl der Dreiecke. Die Farbe der Dreiecke soll nicht schwarz sein. In der Funktion `repeat_triangle` soll die Funktion `triangle` aus Aufgabe 1 genutzt werden. <br>
- *freiwillig* : Jedes Dreieck soll eine eigene Farbe haben.
Eine mögliche Lösung könnte so aussehen (`repeat_triangle(otto, 80, 4)`):
![repeat](https://box.hu-berlin.de/f/7ceeb79b004e4e9f8ab5/?dl=1)
%% Cell type:code id: tags:
```
``` python
import turtle
turtle.colormode(255)
# Aufgabe a
def repeat_triangle(t, l, n):
pass # löschen Sie diese Zeile, wenn Sie anfangen, die Funktion zu implementieren
otto = turtle.Turtle()
repeat_triangle(otto, 80, 4)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Aufgabe 3
Schreiben Sie eine Funktion `pile_triangle`, die `m` gleichseitige Dreiecke übereinander zeichnet. Sie soll drei Argumente `t`, `l` und `m` erhalten. `t` ist ein turtle-Objekt, `l` gibt die Seitenlänge der Dreiecke an und `m` die Anzahl der Dreiecke. Die Farbe der Dreiecke soll nicht schwarz sein. In der Funktion `pile_triangle` soll die Funktion `triangle` aus Aufgabe 1 genutzt werden.
**Achtung**: Im gleichseitigen Dreieck ist die Höhe des Dreiecks gleich die halbe Seitenlänge multipliziert mit der Wurzel aus Drei.
- *frewillig* : Jedes Dreieck soll eine eigene Farbe haben.
Eine mögliche Lösung könnte so aussehen (`pile_triangle(otto, 80, 4)`):
![pile](https://box.hu-berlin.de/f/d6c490e2f4f640349f42/?dl=1)
%% Cell type:code id: tags:
```
``` python
import turtle
turtle.colormode(255)
# Aufgabe a
def pile_triangle(t, l, m):
pass # löschen Sie diese Zeile, wenn Sie anfangen, die Funktion zu implementieren
otto = turtle.Turtle()
pile_triangle(otto, 80, 4)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Aufgabe 4
Schreiben Sie eine Funktion `tiled_triangle`, die `n` gleicheitige Dreiecke nebeneinander und `m` gleichseitige Dreiecke übereinander zeichnet. Sie soll vier Argumente `t`, `l`, `n` und `m` erhalten. `t` ist ein turtle-Objekt, `l` gibt die Seitenlänge der Dreiecke an, `n` die Anzahl der nebeneinanderliegenden Dreiecke und `m` die Anzahl der übereinanderliegenden Dreiecke. Die Farbe der Dreiecke soll nicht schwarz sein. Rufen Sie entweder die Funktion `repeat_triangle` aus Aufgabe 2 oder `pile_triangle` in Ihrer Funktion `tiled_triangle` auf. <br>
- *freiwillig* : Jedes Dreieck soll eine eigene Farbe haben.
- *freiwillig* : Färben Sie auch die Zwischenräume, die hier entstehen
Eine mögliche Lösung könnte so aussehen (`tiled_triangle(otto, 80, 3, 3)`):
![tiled](https://box.hu-berlin.de/f/811e98f587e040098a83/?dl=1)
%% Cell type:code id: tags:
```
``` python
import turtle
turtle.colormode(255)
def tiled_triangle(t, l, n, m):
pass # löschen Sie diese Zeile, wenn Sie anfangen, die Funktion zu implementieren
otto = turtle.Turtle()
tiled_triangle(otto, 80, 3, 3)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Aufgabe 5
Stellen Sie sich vor, sie müssen `tiled_triangle` so verändern, dass die Funktion ein zusätzliches Argument erhält, nämlich die Anzahl der Ecken. (`tiled_triangle(t,l,n,m,ecken)`) Die geometrische Form (bis jetzt das Dreieck) soll also in Zukunft verallgemeinert werden. **Die Funktion selbst müssen Sie nicht schreiben.** An welchen Stellen könnte es aber Schwierigkeiten in Ihrer jetzigen Funktion geben?
%% Cell type:markdown id: tags:
-
-
-
%% Cell type:markdown id: tags:
### Aufgabe 6
Überraschen Sie mich. Seien Sie **kreativ** und malen Sie mit `turtle`, auf was Sie Lust haben :)
Es gibt einige Vorgaben, die im Code enthalten sein müssen:
- entweder eine **Schleife** oder eine **Rekursion**
- mindestens eine **if/elif/else-Bedingung**
- der Code muss in mindestens zwei **Funktionen** verkapselt sein.
Kommentieren Sie Ihren Code.
PS: Entweder schauen Sie in den Notebooks nach oder Sie nutzen Google, um sich zu inspirieren: `google python turtle drawings`.
%% Cell type:code id: tags:
```
``` python
# Hier soll ihr Code stehen
```
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
......
notebooks/hausaufgabe3.ipynb
+ 23
− 5
View file @ e9d70fe6
%% Cell type:markdown id: tags:
<h1>Table of Contents<span class="tocSkip"></span></h1>
<div class="toc"><ul class="toc-item"><li><span><a href="#Aufgabe-1" data-toc-modified-id="Aufgabe-1-1"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 1</a></span></li><li><span><a href="#Aufgabe-2" data-toc-modified-id="Aufgabe-2-2"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 2</a></span></li><li><span><a href="#Aufgabe-3" data-toc-modified-id="Aufgabe-3-3"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 3</a></span></li><li><span><a href="#Aufgabe-4" data-toc-modified-id="Aufgabe-4-4"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 4</a></span></li></ul></div>
%% Cell type:markdown id: tags:
# 3. Hausaufgabe
Geben Sie diese Hausaufgabe gemeinsam mit Ihrem/r Partner/in ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei (`hausaufgabe3.ipynb`) in Moodle hoch. Verwenden Sie Kommentare im Python-Quellcode und Markdown-Textboxen im Jupyter-Notebook ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele)) um ihr Programm zu kommentieren. Für diese Hausaufgabe sollten Sie das 4. bis 6. Kapitel durchgearbeitet haben, da Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.
### Lesen Sie sich die nachfolgenden Hinweise gut durch und folgen Sie den Anweisungen, um Missverständnisse zu vermeiden.
Geben Sie diese Hausaufgabe gemeinsam als Pair Programming Gruppe ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei unter `Hausaufgabe 3` in Moodle hoch. Für diese Hausaufgabe sollten Sie das 4. bis 6. Kapitel durchgearbeitet haben, da Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.
* Geben Sie bitte Ihrem **Notebook einen Namen**, sodass es Ihnen und Ihrem Partner zugeordnet werden kann (z.B. *hausaufgabe2_nachname1_nachname2.ipynb*)
* Fügen Sie außerdem **kurze Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
**Tipps und Anmerkungen**:
- Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht. Passen Sie auf, dass Sie in Moodle auf Abgabe drücken, damit es nicht nur ein Entwurf ist.
- Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!
- Fügen Sie außerdem **kurze Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
- inline-Kommentare (Code kommentieren): `#`
- Docstrings (Beschreibung der Funktion): `''' '''`
- für Kommentare in Markdown-Textboxen im Jupyter-Notebook: ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele))
- Bitte ändern Sie den Dateinamen ihrer Hausaufgabe zu: **hausaufgabe3_nachnamePartnerIn1_nachnamePartnerIn2.ipynb**
- z.B. `hausaufgabe3_hachmeier_jäschke.ipynb`
- Das können Sie einfach machen, indem Sie **jetzt** oben links auf `hausaufgabe3` klicken und den neuen Namen eingeben.
- Falls Sie **generative KI** in der Hausaufgabe genutzt haben wie bspw. ChatGPT: Dokumentieren Sie Ihre Nutzung. Geben Sie alle Eingaben an, die Sie in der jeweiligen Aufgabe verwendet haben und beschreiben Sie, welche Änderungen Sie vor Abgabe zur Anpassung an die jeweilige Aufgabe vornehmen mussten.
- Bei (Verständnis-)Fragen können Sie mich **frühzeitig** und nicht am Abend des Abgabetages per E-Mail oder während der Sitzungen erreichen.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
# Aufgabe 1
Stellen Sie sich vor, Sie spielen Schere-Stein-Papier mit ihrer Partner\*in.
Wer das Spiel nicht kennt:
Zwei Spieler\*innen müssen sich gleichzeitig für eins der drei Symbole (Schere, Stein oder Papier) entscheiden.
Der Gewinner wird folgendermaßen ermittelt:
- Stein schlägt Schere
- Schere schlägt Papier
- Papier schlägt Stein
Falls beide Spieler\*innen dasselbe Symbol ausgewählt haben, wird noch einmal gespielt.
Ihre Aufgabe ist es, einen Durchlauf des Spiels zu implementieren.
1. Schreiben Sie eine Funktion `schere_stein_papier`, die zwei Zeichenketten als Argumente erwartet und "Spieler\*in 1 gewinnt" oder "Spieler\*in 2 gewinnt" ausgibt, abhängig davon, ob Argument 1 gegen Argument 2 gewinnt oder umgedreht.
- Falls die **Argumente gleich** sind, soll eine Mitteilung gemacht werden, dass noch einmal gespielt werden muss.
- Decken Sie auch den Fall ab, dass ein Argument eine **andere Zeichenkette** sein kann, z.B. "Brunnen". Hier soll eine Warnung gezeigt werden, dass einer der Spieler\*innen versucht, zu betrügen.
2. Schreiben Sie eine Funktion, die die **Nutzer\*in bittet, zwei Zeichenketten einzugeben** und dann die Funktion `schere_stein_papier` nutzt, um zu entscheiden, welche Spieler\*in gewonnen hat.
3. **Freiwillig und zum Knobeln**: Schreiben Sie eine Funktion, die drei Durchläufe `schere-stein-papier` spielt und den Gesamtsieger ermittelt.
%% Cell type:code id: tags:
```
# Implementieren Sie hier die Funktionen
def schere_stein_papier(s1, s2):
pass # Diese Zeile können Sie bei der Implementierung der Funktion löschen
```
%% Cell type:code id: tags:
```
schere_stein_papier("Stein", "Papier") # Spieler*in 2 gewinnt
schere_stein_papier("Schere", "Papier") # Spieler*in 1 gewinnt
schere_stein_papier("Papier", "Papier") # Unentschieden
schere_stein_papier("Brunnen", "Papier") # Geschummelt!
# Rufen Sie hier Ihre Funktion mit allen möglichen Kombinationen auf,
# die in den vorherigen Aufrufen noch nicht abgedeckt wurden:
```
%% Cell type:markdown id: tags:
## Aufgabe 2
*(Dies ist [Aufgabe 4 im 5. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar05.ipynb#aufgabe-4).)*
Was gibt das folgende Programm aus? Zeichnen Sie (entweder mit Stift und Papier oder in einem Markdown Feld, siehe ein Beispiel unten) ein Stapeldiagramm (siehe [Abschnitt 3.9](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar03.ipynb#3-9-stapel-diagramme)), das den Zustand des Programms ausgibt, wenn `recurse(3, 0)` aufgerufen wird:
*Hinweis: Laden Sie das digitalisierte Stapeldiagramm zusammen mit diesem Notebook in Moodle hoch. Wenn Sie wollen, können Sie auch ASCII-Textboxen direkt hier einfügen, ungefähr so:*
*Beispiel eines Stapeldiagramms für function_1, die einmal aufgerufen wurde:*
```
+------------------------------------+
function_1 | parameter_1 -> argument_1 |
| parameter_2 -> argument_2 |
+------------------------------------+
```
Für jeden Funktionsaufruf von recurse soll ein neues "Fenster" gezeichnet werden.
**Lösung:**
```
+------------------------------------+
recurse | -> |
| -> |
+------------------------------------+
...
```
%% Cell type:code id: tags:
```
def recurse(n, s):
'''
'''
if n == 0:
print(s)
else:
recurse(n-1, n+s)
recurse(3, 0)
```
%% Cell type:markdown id: tags:
## 2a
Was würde passieren, wenn wir diese Funktion so aufrufen würden: `recurse(-1, 0)`?
**Lösung**:
## 2b
Fügen Sie einen Docstring zur Funktion hinzu, der alles erklärt, was man wissen sollte, um diese Funktion nutzen zu können (und nicht mehr!). Insbesondere soll erwähnt werden, welche Eigenschaften die Parameter haben müssen.
%% Cell type:markdown id: tags:
## Aufgabe 3
*(Das ist [Aufgabe 4 im 6. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar06.ipynb#aufgabe-4).)*
Eine ganze Zahl `a` ist eine Potenz von `b`, wenn `a` durch `b` teilbar ist und `a/b` eine Potenz von `b` ist. (Beispielsweise ist 27 eine Potenz von 3, denn 27 ist durch 3 teilbar und 9 ist eine Potenz von 3.) Schreiben Sie eine Funktion `is_power` die Parameter `a` und `b` erwartet und `True` zurückgibt, wenn `a` eine Potenz von `b` ist (ansonsten `False`).
Sie dürfen die Code aus Kapitel 6 übernehmen. Beantworten Sie dazu folgende Fragen:
- Was ist die Abbruchbedingung/ der Basisfall?
- **Lösung**:
- Markieren Sie im Code, an welchen Stellen der Basisfall definiert wird
- Markieren Sie im Code, an welcher Stelle der rekursive Aufruf stattfindet
- Wieviele unterschiedliche Rückgabewerte sind möglich? Welche Rückgabewerte gibt es?
- **Lösung**:
- Rufen Sie die Funktion `ist_potenz` mit verschiedenen Argumenten so auf, dass die verschiedenen Abbruchbedingungen mindestens einmal durchlaufen werden. Rufen Sie die Funktion außerdem so auf, dass jeder Rückgabewert mindestens einmal herauskommt.
%% Cell type:code id: tags:
```
def ist_potenz(a,b):
```
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
## Aufgabe 4
Ziel dieser Aufgabe ist, eine ASCII-Tabelle für die Zeichen mit dem Code von 32 (dezimal) bis 127 (dezimal) mit den zugehören Hexadezimalcodes auszugeben. Das Ergebnis sollte so aussehen:
```
20 21 ! 22 " 23 # 24 $ 25 % 26 & 27 ' 28 ( 29 ) 2a * 2b + 2c , 2d - 2e . 2f /
30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 7 38 8 39 9 3a : 3b ; 3c < 3d = 3e > 3f ?
40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G 48 H 49 I 4a J 4b K 4c L 4d M 4e N 4f O
50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W 58 X 59 Y 5a Z 5b [ 5c \ 5d ] 5e ^ 5f _
60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g 68 h 69 i 6a j 6b k 6c l 6d m 6e n 6f o
70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w 78 x 79 y 7a z 7b { 7c | 7d } 7e ~
```
Lesen Sie sich den Exkurs am Anfang des [7. Kapitels](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar07.ipynb) durch und **versuchen Sie zu verstehen, wie die Funktion `dez_zu_allem` funktioniert**. Dazu sollte es reichen, die Funktion mit verschiedenen Eingaben aufzurufen und zu verstehen, wie die jeweilige Ausgabe mit der Eingabe zusammenhängt. (Der Parameter `s` stellt das Alphabet für ein Positionssystem dar, wobei alle Zeichen einfach hintereinander als Zeichenkette erwartet werden.)
Rufen Sie die Funktion mit dem Dezimalcode für das Zeichen 'B' auf (diesen finden Sie in der ASCII-Tabelle aus der Vorlesung), so dass der Wert als Hexadezimalzahl zurückgegeben wird. Geben Sie diese Hexadezimalzahl mit `print` aus. (Es sollte '42' ausgegeben werden.)
%% Cell type:code id: tags:
```
# Hilfsfunktion aus Kapitel 7,
def dez_zu_allem(n, s):
if n == 0:
return ""
return dez_zu_allem(n // len(s), s) + s[n % len(s)]
```
%% Cell type:markdown id: tags:
Mit der Funktion `chr` können wir Dezimalzahlen zwischen 0 und 127 in das entsprechende ASCII-Zeichen (als Zeichenkette) umwandeln. Probieren Sie es aus, indem Sie mit Hilfe von `chr` das Zeichen mit dem (dezimalen) ASCII-Code 84 ausgeben. (Es sollte `T` ausgegeben werden.)
%% Cell type:code id: tags:
```
# Fügen Sie hier Ihren Code ein
```
%% Cell type:markdown id: tags:
Schreiben Sie jetzt eine Funktion `zeichentabelle`, die folgende Parameter erwartet:
- `anfang`: die Dezimalzahl des ASCII-Codes des ersten Zeichens, welches ausgegeben werden soll
- `ende`: die Dezimalzahl des ASCII-Codes des letzten Zeichens, welches ausgegeben werden soll
- `trennzeichen`: eine Zeichenkette, die als Trennzeichen zwischen zwei Code-Zeichen-Paaren ausgegeben werden soll
- `paare_pro_zeile`: die Anzahl an Code-Zeichen-Paaren die pro Zeile ausgegeben werden sollen
Die Funktion soll mit Hilfe einer `for`-Schleife und der `range`-Funktion über alle Dezimalzahlen zwischen `anfang` und `ende` (jeweils inklusive) laufen und den Hexadezimalcode sowie das zugehörige Zeichen durch Leerzeichen getrennt ausgeben. Danach soll das `trennzeichen` ausgegeben werden und nach entsprechend vielen Paaren soll eine neue Zeile erzeugt werden.
Hinweis: Sie können bei der `print`-Funktion die Ausgabe eines Zeilenumbruchs unterdrücken, indem Sie dem Parameter `end` einen anderen Wert mitgeben, beispielsweise so:
%% Cell type:code id: tags:
```
print("Spalte 1", end=" | ")
print("Spalte 2", end=" | ")
print("Spalte 3")
```
%% Cell type:code id: tags:
```
def zeichentabelle(anfang, ende, trennzeichen, paare_pro_zeile):
pass # löschen Sie diese Anweisung, wenn Sie anfangen, die Funktion zu implementieren
```
%% Cell type:code id: tags:
```
zeichentabelle(32, 127, " ", 16)
```
%% Cell type:code id: tags:
```
zeichentabelle(32, 127, " ", 10)
```
%% Cell type:markdown id: tags:
Hier folgen weitere Tipps ... versuchen Sie es aber erst einmal ohne diese Tipps.
<a data-flickr-embed="true" href="https://www.flickr.com/photos/jasoneppink/4964471335" title="Spoiler Alert"><img src="https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg" width="320" height="213" alt="Spoiler Alert"></a><script async src="//embedr.flickr.com/assets/client-code.js" charset="utf-8"></script>
Der Restoperator `%` kann Ihnen helfen, im richtigen Rhythmus Zeilenumbrüche einzufügen.
<a data-flickr-embed="true" href="https://www.flickr.com/photos/jasoneppink/4964471335" title="Spoiler Alert"><img src="https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg" width="320" height="213" alt="Spoiler Alert"></a><script async src="//embedr.flickr.com/assets/client-code.js" charset="utf-8"></script>
Sie müssen den Rest der aktuellen Zahl bei Division durch `paare_pro_zeile` prüfen.
<a data-flickr-embed="true" href="https://www.flickr.com/photos/jasoneppink/4964471335" title="Spoiler Alert"><img src="https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg" width="320" height="213" alt="Spoiler Alert"></a><script async src="//embedr.flickr.com/assets/client-code.js" charset="utf-8"></script>
Es ist etwas knifflig, die Zeilen mit dem richtigen Wert beginnen zu lassen (im Beispiel `20`, `30`, `40`). Das ist ganz normal und sie müssen etwas probieren, um das zu schaffen.
<a data-flickr-embed="true" href="https://www.flickr.com/photos/jasoneppink/4964471335" title="Spoiler Alert"><img src="https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg" width="320" height="213" alt="Spoiler Alert"></a><script async src="//embedr.flickr.com/assets/client-code.js" charset="utf-8"></script>
Probieren Sie verschiedene Werte für den Rest durch, dann sollte es klappen.
Da Python Unicode unterstützt können mit der `chr`-Funktion alle Zeichen aus dem Unicode-Vorrat ausgegeben werden. Probieren Sie es einmal mit Zahlen größer als 127 aus:
%% Cell type:code id: tags:
```
print(chr(2000))
print(chr(4000))
print(chr(8000))
print(chr(16000))
print(chr(32000))
print(chr(64000))
```
%% Cell type:markdown id: tags:
Und wenn Sie bis hierher gekommen sind: geben Sie eine Tabelle von Zeichen aus einem anderen Schriftsystem Ihrer Wahl aus, indem Sie Ihre Funktion `zeichentabelle` mit anderen Start- und Endwerten aufrufen:
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
![Smiley](https://upload.wikimedia.org/wikipedia/commons/0/0f/Face-glasses.svg)
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
......
notebooks/hausaufgabe4.ipynb
+ 20
− 6
View file @ e9d70fe6
%% Cell type:markdown id: tags:
<h1>Table of Contents<span class="tocSkip"></span></h1>
<div class="toc"><ul class="toc-item"><li><span><a href="#Aufgabe-1" data-toc-modified-id="Aufgabe-1-1"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 1</a></span></li><li><span><a href="#Aufgabe-2" data-toc-modified-id="Aufgabe-2-2"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 2</a></span></li><li><span><a href="#Aufgabe-3" data-toc-modified-id="Aufgabe-3-3"><span class="toc-item-num">&nbsp;&nbsp;</span>Aufgabe 3</a></span></li></ul></div>
%% Cell type:markdown id: tags:
# 4. Hausaufgabe
Geben Sie diese Hausaufgabe gemeinsam mit Ihrem/r Partner/in ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei (`hausaufgabe4.ipynb`) in Moodle hoch. Verwenden Sie Kommentare im Python-Quellcode und Markdown-Textboxen im Jupyter-Notebook ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele)) um ihr Programm zu kommentieren. Für diese Hausaufgabe sollten Sie alles bis zum 10. Kapitel durchgearbeitet haben, da Iteration, Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.
### Lesen Sie sich die nachfolgenden Hinweise gut durch und folgen Sie den Anweisungen, um Missverständnisse zu vermeiden.
Geben Sie diese Hausaufgabe gemeinsam als Pair Programming Gruppe ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei unter `Hausaufgabe 4` in Moodle hoch. Für diese Hausaufgabe sollten Sie alles bis zum 10. Kapitel durchgearbeitet haben, da Iteration, Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.
- Geben Sie bitte Ihrem Notebook einen Namen, sodass es Ihnen und Ihrem Partner zugeordnet werden kann (z.B. nachname1_nachname2_hausaufgabe2.ipynb)
* Fügen Sie außerdem **Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
**Tipps und Anmerkungen**:
- Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht. Passen Sie auf, dass Sie in Moodle auf Abgabe drücken, damit es nicht nur ein Entwurf ist.
- Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!
- Fügen Sie außerdem **kurze Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht. Dies kann man durch zwei Varianten machen:
- inline-Kommentare (Code kommentieren): `#`
- Docstrings (Beschreibung der Funktion): `''' '''`
- für Kommentare in Markdown-Textboxen im Jupyter-Notebook: ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele))
- Bitte ändern Sie den Dateinamen ihrer Hausaufgabe zu: **hausaufgabe4_nachnamePartnerIn1_nachnamePartnerIn2.ipynb**
- z.B. `hausaufgabe4_hachmeier_jäschke.ipynb`
- Das können Sie einfach machen, indem Sie **jetzt** oben links auf `hausaufgabe4` klicken und den neuen Namen eingeben.
- Falls Sie **generative KI** in der Hausaufgabe genutzt haben wie bspw. ChatGPT: Dokumentieren Sie Ihre Nutzung. Geben Sie alle Eingaben an, die Sie in der jeweiligen Aufgabe verwendet haben und beschreiben Sie, welche Änderungen Sie vor Abgabe zur Anpassung an die jeweilige Aufgabe vornehmen mussten.
- Falls es **Musterlösungen in den Übungen** gibt, können Sie gerne diese Code übernehmen (eigener Code ist natürlich schöner). Falls Sie das machen, muss aber durch ihre Kommentare hervorgehen, dass Sie den Code verstanden haben.
- Bei (Verständnis-)Fragen können Sie mich **frühzeitig** und nicht am Abend des Abgabetages per E-Mail oder während der Sitzungen erreichen.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
## Aufgabe 1
Implementieren Sie die folgenden Funktionen und rufen Sie ihre Funktionen mit verschiedenen Argumenten auf, um sie auf Funktionalität zu testen.
### 1a
Schreiben Sie eine Funktion, die als Parameter eine Zeichenkette erwartet und prüft, ob das erste Zeichen der Zeichenkette ein Kleinbuchstaben ist. Die Funktion soll einen Wahrheitswert zurückgeben.
%% Cell type:code id: tags:
```
def is_lower_first_char(s):
pass
is_lower_first_char("Test")
is_lower_first_char("test")
is_lower_first_char("tEST")
is_lower_first_char("TESt")
is_lower_first_char("TesT")
```
%% Cell type:markdown id: tags:
### 1b
Schreiben Sie eine Funktion, die als Parameter eine Zeichenkette erwartet und prüft, ob das erste **oder** das letzte Zeichen Kleinbuchstaben sind. Die Funktion soll einen Wahrheitswert zurückgeben.
%% Cell type:code id: tags:
```
def is_lower_first_last_char(s):
pass
is_lower_first_last_char("Test")
is_lower_first_last_char("test")
is_lower_first_last_char("tEST")
is_lower_first_last_char("TESt")
is_lower_first_last_char("TesT")
```
%% Cell type:markdown id: tags:
### 1c
Schreiben Sie eine Funktion, die als Parameter eine Zeichenkette erwartet und prüft, ob **alle** Zeichen der Zeichenkette Ziffern (0,...,9) sind. Die Funktion soll einen Wahrheitswert zurückgeben.
%% Cell type:code id: tags:
```
def is_number(s):
pass
is_number("9847")
is_number("9.312")
is_number("T238ws")
is_number("+4917600011100")
is_number("0049176-00011100")
is_number("004917600011100")
```
%% Cell type:markdown id: tags:
### 1d
Schreiben Sie jeweils eine Funktion, die als Parameter eine Zeichenkette erwartet und alle Ziffern innerhalb einer Zeichenkette ausgibt.
%% Cell type:code id: tags:
```
def return_digits(s):
pass
return_digits("123123")
return_digits("9847")
return_digits("9.312")
return_digits("T238ws")
return_digits("Die Hausaufgabenabgabe ist am 13.Februar 2022.")
return_digits("Und zwar vor 00:00.")
```
%% Cell type:markdown id: tags:
### 1e
Schreiben Sie eine Funktion, die als Parameter zwei Zeichenketten `s` und `w` erwartet und **alle** Vorkommen von `w` innerhalb von `s` zählt. Hierbei soll Groß-/Kleinschreibung ignoriert werden.
Hinweis: Falls das Wort *USA* gefunden werden soll, sollen auch *usa, Usa, uSa*, usw. gefunden werden.
%% Cell type:code id: tags:
```
def count_occ(s, w):
pass
count_occ("Yippie yippie Yeah YiPPIE Yeah, Krawall und Remmi Demmi! Yippi YIPI Yeah YIPPIE Yeah, Krawall und Remmi Demmi!", "yippie")
```
%% Cell type:markdown id: tags:
## Aufgabe 2
Schreiben Sie eine Funktion, die eine Zeichenkette als Parameter erwartet und die Zeichenkette folgendermaßen ändert.Nutzen Sie dafür **nur** [eingebauten Methoden ("built-in methods")](https://docs.python.org/3/library/stdtypes.html#string-methods), für jeden Task eine neue.
- Alle Leerzeichen am Anfang und Ende der Zeichenkette sollen gelöscht werden
- Alle Minus-Zeichen ("-") sollen durch Unterstriche ("_") ersetzt werden
- Der gesamte Text soll nur noch aus Kleinbuchstaben bestehen
%% Cell type:code id: tags:
```
def process_text(s):
pass
process_text(" The function Return-Digits(S) returns all digits of a string. BELIEVE ME. ... ")
```
%% Cell type:markdown id: tags:
## Aufgabe 3
Schreiben Sie eine Funktion, die als Parameter zwei Listen `l` und `d` erwartet und **alle** Elemente aus der Liste `l`, die auch in `d` vorkommen, löscht. Die Rückgabe soll die modifizierte Liste `l` sein.
%% Cell type:code id: tags:
```
def del_elements(l, d):
pass
del_elements([1,3,5,7,9,11,13,15,17,19,21,23,25,27,29], [9,15,21,25])
```
%% Cell type:markdown id: tags:
![Smiley](https://upload.wikimedia.org/wikipedia/commons/0/0f/Face-glasses.svg)
%% Cell type:markdown id: tags:
![CC-BY-NC](https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/cc-by-nc.png)
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
......
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