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

updated ha1 und ha2

parent d7c9e642
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
notebooks/hausaufgabe1.ipynb
+ 43
− 27
View file @ 385e8841
%% 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>
%% Cell type:markdown id: tags:
# 1. 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 (hausaufgabe1.ipynb) in Moodle hoch. Verwenden Sie Kommentare im Python-Quellcode (#), um ihr Programm zu kommentieren.
Bitte ändern Sie den Dateinamen ihrer Hausaufgabe zu: **hausaufgabe1_nachnamePartner1_nachnamePartner2.ipynb**
z.B. hausaufgabe1_schwab_jaeschke.ipynb
Das können Sie einfach machen, indem Sie **jetzt** oben links auf `hausaufgabe1` klicken und den neuen Namen eingeben.
Nutzen Sie das Wissen aus den bisher bearbeiteten Notebooks (1-3).
Es reicht, wenn ein Gruppenmitglied die Hausaufgabe einreicht.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
**Tipp**: Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!
%% 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?
Nutzen Sie entweder Kommentare (mit Hilfe von der Raute #) im Code oder Sie schreiben die Antworten in eine extra Markdown Zeile.
Falls Sie Kommentare (#) nutzen, nehmen 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 ;) )
- Welche Funktionen werden genutzt und was machen diese Funktionen? (die print-Funktion muss nicht erklärt 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 ;) )
%% Cell type:code id: tags:
```
# Beispiel:
print("a"+"b")
#zwei Zeichenketten werden durch den Operator "+" verkettet
# und durch die print()-Funktion ausgegeben.
# zwei Zeichenketten werden durch den Operator "+" verkettet
# Ausgabe: "ab" (Zeichenkette)
# Hier könnte Ihre Erklärung zur ersten Codezeile stehen.
# Hier könnte die zweite Zeile der Erklärung zur ersten Codezeile stehen
print(2 + 3)
print(2.2 + 3.3)
print('2' + '3')
print('2.2' + '3.3')
print(str(2) + str(3))
print(str(2.2) + str(3.3))
print(int('2') + int('3'))
print(int('2' + '3'))
print(float('2') + float('3'))
print(float('2' + '3'))
print(int(2.6 + 2.6))
print(int(2.6) + int(2.6))
```
%% Cell type:markdown id: tags:
## Aufgabe 2
### Aufgabe 2a
**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.
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:
```
def boxprint(zeichenkette):
'''Beschreibung der Funktion: Diese Funktion nimmt als Argument eine Zeichenkette entgegen und gibt
die Zeichenkette innerhalb einer Box aus.
'''Die Funktion nimmt eine Zeichenkette entgegen und gibt
die Zeichenkette innerhalb einer Textbox aus.
'''
```
%% Cell type:code id: tags:
```
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
# Funktionsaufrufe
boxprint("Hello World!")
boxprint("Dieser Text muss auch in die Box passen.")
boxprint("Das Reh springt hoch, das Reh springt weit. Warum auch nicht, es hat ja Zeit.")
# Schreiben Sie hier mindestens zwei Funktionsaufrufe:
```
%% 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.
**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:
```
def stegosay(z):
'''Diese Funktion nimmt als Argument eine Zeichenkette entgegen und gibt
die Zeichenkette als Denkblase eines Dinos wieder aus.
'''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.
'''
```
%% Cell type:code id: tags:
```
# 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 mit einem Rasterabstand von 0.2 berechnet (d.h., für die Werte 0, 0.2, 0.4, 0.6, ..., 6.2).
- Denken Sie daran, dass Sie mit der `int`-Funktion eine Gleitkommazahl in eine ganze Zahl umwandeln können (der Dezimalanteil wird abgeschnitten).
- Damit Sie die Funktion `math.sin` nutzen können, müssen Sie anfangs das `math`-Modul importieren.
- Falls Sie das Problem nicht lösen können, fragen Sie im Seminar nach. Dort können Sie wertvolle Tipps erhalten.
Tipp: Nutzen Sie die `print`-Funktion, um die Sternchen an verschiedenen Stellen zu zeichnen.
%% Cell type:code id: tags:
```
# Beispiel einer einfachen while-Schleife
i = 0
while i < 5:
print(i)
i = i + 1
```
%% Cell type:code id: tags:
```
import math
def sinprint():
'''Implementieren Sie hier ihre Funktion. Dieses Kommentar können Sie löschen.
Diese Funktion kann man ohne Parameter implementieren. Wenn es für Sie einfacher ist,
können Sie gerne eins hinzufügen.
'''
'''Diese Funktion zeichnet eine Sinus-Kurve ohne eine plot-Bibliothek.'''
```
%% Cell type:code id: tags:
```
# Bitte nutzen Sie diese Zelle, um Ihre Funktion aufzurufen.
# 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:
```
import math
def funcprint():
'''Implementieren Sie hier ihre Funktion. Dieses Kommentar können Sie löschen.
Der/Die Parameter müssen Sie sich dieses Mal selbst überlegen. Geben Sie den Parametern sinvolle Namen.
def funcprint(func):
'''Diese Funktion nimmt den Parameter `func` entgegen, der ein Funktionsobjekt repräsentiert und zeichnet
die Funktionskurve
'''
```
%% Cell type:code id: tags:
```
# Bitte nutzen Sie diese Zelle, um Ihre Funktion zweimal mit unterschiedlichen Argumenten aufzurufen.
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)
Ändern Sie die Funktion `funcprint`, so dass alle diese Werte als Argumente übergeben werden können. Testen Sie die Funktion dann mit der Funktion `math.log` als Argument. Dafür müssen Sie den Anfangswert so ändern, dass 0 nicht enthalten ist (da der Logarithmus von 0 nicht definiert ist).
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:
```
import math
def funcprint_advanced():
'''Implementieren Sie hier ihre Funktion. Dieses Kommentar können Sie löschen.
Der/Die Parameter müssen Sie sich dieses Mal selbst überlegen. Geben Sie den Parametern sinvolle Namen.
def funcprint_advanced(func, start, end, step, shift, scale_x, 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.
'''
```
%% Cell type:code id: tags:
```
# Bitte nutzen Sie diese Zelle, um Ihre Funktion zweimal mit unterschiedlichen Argumenten aufzurufen.
funcprint_advanced(math.cos, 2, 10, 0.1, 30, 15, 10)
```
%% Cell type:markdown id: tags:
![Smiley](https://upload.wikimedia.org/wikipedia/commons/0/0f/Face-glasses.svg)
......
notebooks/hausaufgabe2.ipynb
+ 76
− 104
View file @ 385e8841
%% 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.
* Geben Sie bitte Ihrem **Notebook einen Namen**, sodass es Ihnen und Ihrem Partner zugeordnet werden kann (z.B. *hausaufgabe2_nachname1_nachname2.ipynb*)
* Für das Aufwärmen sind in den Seminar-Notebooks schon Musterlösungen gegeben, die nur geringfügig angepasst werden müssen. Falls Sie eine davon nutzen, **ändern Sie zumindest die Namen der Argument und Variablen.**
* Fügen Sie außerdem **Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht (Schleife, Bedingungen, etc. beschreiben). Dies kann man durch zwei Varianten machen:
- \# --> inline-Kommentare zum Code selbst
- ''' ''' --> Docstrings: Funktionsbeschreibung
* Schauen Sie sich das notebook **[FAQ.ipynb](FAQ.ipynb)** an, hier sind turtle-Methoden beschrieben, die Sie in dieser Hausaufgabe nutzen können.
* In jedem Codeblock steht eine **Testfunktion**, die am Ende die von Ihnen definierte Funktion aufruft. Dies sollte funktionieren (dort kann man auch direkt ablesen, wieviele und welche Argumente gebraucht werden). Anfangs können Sie den Aufruf gerne auskommentieren, damit nicht immer eine Fehlermeldung angezeigt wird (danach wieder Kommentare entfernen).
* 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 in den Aufgaben 2-5).
* Sie dürfen natürlich auch andere Funktionen des turtle-Moduls nutzen (siehe https://docs.python.org/3/library/turtle.html).
* Bitte geben Sie nur **eine Lösung pro Aufgabe** ab.
* **Zusatz** = freiwillig
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
### Hilfsfunktion:
%% Cell type:code id: tags:
```
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:
```
from random import randint
def setcolor(t,n):
''' nimmt eine Turte und eine Ganzzahl entgegen und ändert die Farbe der gezeichneten Linien (n = 1) oder die
Farbe der gezeichneten Linien und die Farbe der turtle selbst (n = 2) bei jedem Aufruf zufällig'''
turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren
if n==1: #setze n=1, um die Schildkröte und Formen in der gleichen Farbe zu färben
t.color(randint(0,255),randint(0,255),randint(0,255)) #generiert eine zufällige Farbe für die turtle
if n==2: # setze n=2, um Schildkröte und Formen in unterschiedlichen Farben zu färben
t.color((randint(0,255),randint(0,255),randint(0,255)),(randint(0,255),randint(0,255),randint(0,255)))
```
%% Cell type:code id: tags:
```
# Beispielcode zur Hilfsfunktion
import turtle
caro = turtle.Turtle()
turtle.colormode(255)
for i in range(20):
for i in range(4):
caro.fd(100)
caro.lt(90)
# Aufruf der Hilfsfunktion am Ende der Schleife,
# Aufruf am Ende des Schleifendurchlaufs,
#um im nächsten Schleifendurchlauf die Linie und die turtle neu zu färben
# caro.color(setcolor())
setcolor(t,1)
t.color(setcolor())
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
## Aufwärmen
### Aufgabe 0
Schreiben Sie eine Funktion `square`, die zwei Parameter `t` und `length` erwartet. `t` ist eine Schildkröte, `length` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um ein Quadrat mit Seitenlänge `length` zu zeichnen.
%% Cell type:code id: tags:
```
import turtle
# Implementieren Sie hier ihre Funktion und schreiben Sie Kommentare dazu
caro.color(setcolor())
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
otto = turtle.Turtle()
square(t = otto, length = 100)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
## Aufgaben
### Aufgabe 1
Schreiben Sie eine Funktion `triangle`, die zwei Parameter `t` und `l` erwartet. `t` ist eine Schildkröte, `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.
%% Cell type:code id: tags:
```
import turtle
# Implementieren Sie hier ihre Funktion und schreiben Sie Kommentare dazu
def triangle(t, length):
pass # löschen Sie diese Anweisung, wenn Sie anfangen, die Funktion zu implementieren
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
otto = turtle.Turtle()
triangle(otto, 100)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### eingebaute turtle-Methoden:
- Dokumention von python: https://docs.python.org/3/library/turtle.html
- Dort finden Sie alle Funktionen, die Sie auf Ihre Schildkröte 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(c)`, wobei `c` eine Zeichenkette ist (z.B. 'red', 'green', etc.)
- `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(x)` können Sie der turtle verschiedene Geschwindigkeiten geben (`x` ist eine Zahl zwischen 1 und 100)
%% Cell type:code id: tags:
```
import turtle
# Implementieren Sie hier ihre Funktion und schreiben Sie Kommentare dazu
turtle.colormode(255)
def square(t, l):
t.shape('turtle')
t.begin_fill()
for i in range(4):
t.stamp()
t.fd(l)
t.lt(90)
t.color(setcolor())
t.end_fill()
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
otto = turtle.Turtle()
square(otto, 500)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Aufgabe 2
#### a
Nutzen Sie die Funktionen, um die Schildkröte in einer Farbe Ihrer Wahl zu färben. Dies können Sie direkt in Ihren Code aus Aufgabe 2 einbauen. Sie können aber auch einen neuen Codeblock erstellen.
#### b
Nutzen Sie die Funktionen, um Ihr Dreieck in einer Farbe Ihrer Wahl zu färben.
#### c
Nutzen Sie die Funktionen, um an jeder Ecke Ihres Dreiecks eine Schildkröte zu platzieren.
%% Cell type:markdown id: tags:
### Aufgabe 3
Schreiben Sie eine Funktion `repeat_triangle`, die **vier Dreiecke nebeneinander** zeichnet. Sie soll zwei Argumente `t` und `l` erhalten. `t` ist eine Schildkröte, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um die gleichseitigen Dreiecke mit Seitenlänge `l` zu zeichnen. Die Farbe der Dreiecke soll nicht schwarz sein. Nutzen Sie dafür Ihre Lösung aus Aufgabe 2. <br>
- *Zusatz*: Jedes Dreieck soll eine eigene Farbe haben.
- *Zusatz*: Verändern Sie die Funktion so, dass sie eine variable Anzahl von Dreiecken zeichnen kann, die als Argument übergeben wird.
a) Schreiben Sie eine Funktion `repeat_triangle`, die **vier Dreiecke nebeneinander** zeichnet. Sie soll zwei Argumente `t` und `l` erhalten. `t` ist eine Schildkröte, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um die gleichseitigen Dreiecke mit Seitenlänge `l` zu zeichnen. Die Farbe der Dreiecke soll nicht schwarz sein. In der Funktion `repeat_triangle` soll die Funktion `triangle` aus Aufgabe 2 aufgerufen werden. <br>
- Eine mögliche Lösung könnte so aussehen:
b) Verändern Sie die Funktion so, dass sie eine variable Anzahl von Dreiecken zeichnen kann, die als Argument übergeben wird.
- *Zusatz* : Jedes Dreieck soll eine eigene Farbe haben.
Eine mögliche Lösung könnte so aussehen:
![repeat](https://box.hu-berlin.de/f/7ceeb79b004e4e9f8ab5/?dl=1)
%% Cell type:code id: tags:
```
import turtle
# Implementieren Sie hier ihre Funktion und schreiben Sie Kommentare dazu
def repeat(t, l, anzahl):
for i in range(anzahl):
# Aufgabe a
def repeat_triangle(t, length):
pass # löschen Sie diese Anweisung, wenn Sie anfangen, die Funktion zu implementieren
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
otto = turtle.Turtle()
repeat_triangle(otto, 80, 6)
repeat_triangle(otto, 80)
turtle.mainloop()
turtle.bye()
```
%% Cell type:code id: tags:
```
import turtle
# Aufgabe b
def repeat_triangle(t, length, number):
pass # löschen Sie diese Anweisung, wenn Sie anfangen, die Funktion zu implementieren
otto = turtle.Turtle()
repeat_triangle(otto, 100, 6)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Aufgabe 4
Schreiben Sie eine Funktion `pile_triangle`, die **vier Dreiecke übereinander** zeichnet. Sie soll zwei Argumente `t` und `l` erhalten. `t` ist eine Schildkröte, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um die gleichseitigen Dreiecke mit Seitenlänge `l` zu zeichnen. Die Farbe der Dreiecke soll nicht schwarz sein. Nutzen Sie dafür Ihre Lösung aus Aufgabe 2. <br>
a) Schreiben Sie eine Funktion `pile_triangle`, die **vier Dreiecke übereinander** zeichnet. Sie soll zwei Argumente `t` und `l` erhalten. `t` ist eine Schildkröte, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um die gleichseitigen Dreiecke mit Seitenlänge `l` zu zeichnen. Die Farbe der Dreiecke soll nicht schwarz sein. In der Funktion `pile_triangle` soll die Funktion `triangle` aus Aufgabe 2 aufgerufen werden.
b) Verändern Sie die Funktion so, dass sie eine variable Anzahl von Dreiecken zeichnen kann, die als Argument übergeben wird.
- *Zusatz* : Jedes Dreieck soll eine eigene Farbe haben.
- *Zusatz*: Verändern Sie die Funktion so, dass sie eine variable Anzahl von Dreiecken zeichnen kann, die als Argument übergeben wird.
- Eine mögliche Lösung könnte so aussehen:
Eine mögliche Lösung könnte so aussehen:
![pile](https://box.hu-berlin.de/f/d6c490e2f4f640349f42/?dl=1)
%% Cell type:code id: tags:
```
import turtle
# Implementieren Sie hier ihre Funktion und schreiben Sie Kommentare dazu
# Aufgabe a
def pile_triangle(t, length):
pass # löschen Sie diese Anweisung, wenn Sie anfangen, die Funktion zu implementieren
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
otto = turtle.Turtle()
pile_triangle(otto, 80)
turtle.mainloop()
turtle.bye()
```
%% Cell type:code id: tags:
```
import turtle
# Aufgabe b
def pile_triangle(t, length, number):
pass # löschen Sie diese Anweisung, wenn Sie anfangen, die Funktion zu implementieren
otto = turtle.Turtle()
pile_triangle(otto, 100, 2)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Aufgabe 5
Schreiben Sie eine Funktion `tiled_triangle`, die **drei Dreiecke übereinander und drei Dreiecke nebeneinander** zeichnet. Sie soll zwei Argumente `t` und `l` erhalten. `t` ist eine Schildkröte, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um die gleichseitigen Dreiecke mit Seitenlänge `l` zu zeichnen. Die Farbe der Dreiecke soll nicht schwarz sein. Nutzen Sie dafür Ihre Lösung aus Aufgabe 2 und Aufgabe 3 oder Aufgabe 4. <br>
- *Zusatz* : Jedes Dreieck soll eine eigene Farbe haben.
- *Zusatz* : Färben Sie auch die Zwischenräume, die hier entstehen
- Eine mögliche Lösung könnte so aussehen:
![tiled](https://box.hu-berlin.de/f/811e98f587e040098a83/?dl=1)
%% Cell type:code id: tags:
```
import turtle
# Implementieren Sie hier ihre Funktion und schreiben Sie Kommentare dazu
def tiled_triangle(t, length):
pass # löschen Sie diese Anweisung, wenn Sie anfangen, die Funktion zu implementieren
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
otto = turtle.Turtle()
tiled_triangle(otto, 80)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Aufgabe 6
Schreiben Sie eine Funktion `tiled_triangle`, die **n Dreiecke übereinander und m Dreiecke nebeneinander** zeichnet. Sie soll vier Argumente `t`, `l`, `n` und `m` erhalten. `t` ist eine Schildkröte, `l`, `n` und `m` Ganzzahlen. Die Funktion soll die Schildkröte nutzen, um `n` gleichseitige Dreiecke mit Seitenlänge `l` übereinander und `m` gleichseitige Dreiecke mit Seitenlänge `l` nebeneinander zu zeichnen. <br>
%% Cell type:code id: tags:
```
import turtle
# Implementieren Sie hier ihre Funktion und schreiben Sie Kommentare dazu
def tiled_triangle(t, length, m, n):
pass # löschen Sie diese Anweisung, wenn Sie anfangen, die Funktion zu implementieren
# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu
otto = turtle.Turtle()
tiled_triangle(otto, 80,4,6)
turtle.mainloop()
turtle.bye()
```
%% Cell type:markdown id: tags:
### Aufgabe 7
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,m,n,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?
- *Freiwillig*: Versuchen Sie, eine solche Funktion zu implementieren (VORSICHT: Es gibt hierzu noch keine "schöne" Lösung!).
%% Cell type:markdown id: tags:
-
-
-
-
%% Cell type:markdown id: tags:
### Aufgabe 8
Ü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:
- mindestens eine **Schleife**
- mindestens eine **if/else-Anweisung**
- der Code muss in mindestens zwei **Funktionen** verkapselt sein.
Kommentieren Sie Ihren Code. Beschreiben Sie, was die Schleifen, if-Anweisungen und Funktionen machen.
PS: Entweder schauen Sie in den Notebooks nach, um sich Ideen zu holen, Google kann auch inspieren: "google python turtle drawings".
%% Cell type:code id: tags:
```
# Hier soll ihr Code stehen
```
......
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