1. Erste Programme
a) Schreibe die Befehle auf, mit denen die Turtle die eingezeichnete Strecke aus der Startposition zurücklegt. Die Turtle startet oben rechts und blickt nach rechts. Jedes Kästchen hat die Seitenlänge 10.
b) Zeichne die Strecke ein, welche die Turtle bei der Ausführung des folgenden Programms aus der Startposition zurücklegt:
forward(60) right(45) forward(28.3) right(45) forward(50) right(90) forward(40) left(45) back(28.3) right(90) forward(28.3) left(45) forward(40) left(90) back(30)
Die Turtle startet immer mit Blickrichtung nach oben (Norden). Verwende die Befehle forward(s), back(s), right(w) und left(w). Beachte: Diagonale Strecken über ein 10×10-Kästchen haben die Länge √(10²+10²) ≈ 14.14.
Schreibe ein Programm, mit dem die Turtle das abgebildete Haus zeichnet. Alle Strecken sind gleich lang (100). Das Dach ist ein gleichseitiges Dreieck.
Wie muss das Programm aussehen, wenn die Turtle keine der Strecken zweimal zeichnen/abfahren darf?
Das Haus besteht aus einem Quadrat (4 × 100) und einem gleichseitigen Dreieck als Dach. Die Innenwinkel eines gleichseitigen Dreiecks betragen 60°. Überlege dir, in welcher Reihenfolge du die Strecken abfährst, damit keine doppelt gezeichnet wird – beginne z.B. unten links und fahre im Uhrzeigersinn.
Schreibe ein Programm, mit dem die Turtle vom Start ins Ziel gelangt.
Einschränkung: Verwende im Programm ausschliesslich die Befehle back() und right().
Die Strecken sind: rechts unten Start, Seitenlängen 50 und 40, Winkel 60°, 135°. Ziel ist links unten.
Mit back() bewegt sich die Turtle rückwärts (entgegen der Blickrichtung). Mit right(w) drehst du sie im Uhrzeigersinn. Da left() nicht erlaubt ist, kannst du stattdessen right(360 - w) verwenden, um denselben Effekt zu erzielen.
Ein Vieleck ist regelmässig, wenn alle Seiten gleich lang und alle Winkel gleich gross sind.
Schreibe je ein Programm, das ein regelmässiges Fünfeck und Sechseck mit Seitenlänge 80 zeichnet.
Bei einem regelmässigen n-Eck dreht sich die Turtle bei jeder Ecke um 360/n Grad. Für ein Fünfeck also 360/5 = 72°, für ein Sechseck 360/6 = 60°. Du wiederholst n-mal: vorwärts + drehen.
Schreibe ein Programm, das den fünfzackigen Stern zeichnet. Die Zackenwinkel betragen 36° und die Einbuchtungswinkel 108°. Den Startpunkt der Turtle kannst du beliebig wählen.
Ein fünfzackiger Stern entsteht, wenn du 5-mal vorwärts gehst und dich dann um 144° drehst (das ist 180 - 36). Alternativ: Zeichne 5 Linien, wobei du dich nach jeder Linie um 144° nach rechts drehst.
2. Wiederholungen
Neue Syntax: Anstelle von repeat n: (TigerJython) verwenden wir die Python-Schreibweise for i in range(n):
Schreibe ein Programm, das ein regelmässiges 12-Eck mit Seitenlänge 50 zeichnet.
Tipp aus dem Skript: Mit hideTurtle() bzw. ht() kann die Turtle ausgeblendet werden. Das Zeichnen wird dann massiv beschleunigt.
Bei einem 12-Eck dreht sich die Turtle bei jeder Ecke um 360/12 = 30°. Verwende eine Schleife: for i in range(12): mit forward(50) und right(30).
Schreibe ein Programm, welches die abgebildete Figur mit 50 Strahlen der Länge 100 zeichnet (sieht aus wie eine Sonne/Kreis aus Strahlen).
Zeichne 50-mal einen Strahl: forward(100), gehe zurück mit back(100), drehe dich um 360/50 = 7.2°. Verwende for i in range(50):
Programm (a): Die Ausgabe sollte ein Quadrat mit Seitenlänge 150 sein, es ist aber etwas falsch. Ändere einen der drei Parameter so, dass die Ausgabe korrekt ist!
from gturtle import *
makeTurtle()
for i in range(4):
fd(50)
lt(90)
fd(200)
Programm (b): Was ist die Ausgabe des folgenden Programms?
from gturtle import *
makeTurtle()
for i in range(3):
rt(60)
fd(100)
(a): Ein Quadrat mit Seitenlänge 150 hat 4 gleich lange Seiten. Im Schleifenkörper werden aber zwei verschiedene Längen verwendet (50 und 200). Überlege, welcher Wert geändert werden muss.
(b): Zeichne die Bewegungen der Turtle Schritt für Schritt auf Papier. Die Turtle dreht sich 3-mal um 60° nach rechts und geht jeweils 100 vorwärts.
Schreibe ein Programm, welches das abgebildete Kreuz zeichnet. Die Arme sind 50 Pixel lang und breit. Das Programm soll so wenig Zeilen haben wie möglich.
Ein Kreuz besteht aus einem Muster, das sich 4-mal wiederholt (einmal pro Arm). Jeder Arm besteht aus: vorwärts, rechts, vorwärts, rechts, vorwärts, links. Finde das sich wiederholende Muster und verwende for i in range(4):
a) Schreibe ein Programm, das einen Kreis zeichnet.
b) Ändere dein Programm so ab, dass der Kreis den Radius 100 hat. (Tipp: π ≈ 3.1415)
(a): Ein Kreis ist ein Vieleck mit sehr vielen Seiten. Verwende z.B. ein 360-Eck: for i in range(360): forward(1); right(1)
(b): Der Umfang eines Kreises ist U = 2 × π × r. Bei 360 Schritten ist jeder Schritt U / 360 lang. Für r=100: Schrittlänge ≈ 1.745
Schreibe ein möglichst kurzes Programm, das die folgende Melodie spielt (Tonleiter in Viertelnoten: c', d', e', f' – dann Pause – dann e', f', e', d' etc.).
Frequenzen: c'=261, d'=293, e'=329, f'=349, g'=391, a'=440, h'=493, c''=523 Hz. Viertel = 500 ms.
Verwende den Befehl playTone(freq, t) für Töne und delay(t) für Pausen. Schaue, ob sich Muster in der Melodie wiederholen, die du mit einer Schleife abkürzen kannst.
a) Schreibe ein Programm, das ein Zifferblatt mit einem Durchmesser von 420 zeichnet. Wähle für die Stundenstriche die Länge=30 und die Breite=15.
b) Ergänze das Programm mit einer zweiten Schleife, welche die Minutenstriche zeichnet. Wähle für die Minutenstriche die Länge=10 und Breite=3.
(a): Es gibt 12 Stundenstriche, also drehst du dich um 360/12 = 30°. Für jeden Strich: Stift heben, zum Rand fahren, Stiftbreite setzen, Strich zeichnen, zurück zur Mitte, drehen.
(b): 60 Minutenstriche mit 360/60 = 6° Drehung. Benutze setPenWidth(3) und Länge 10.
Färbe den Flächeninhalt des Sterns aus Aufgabe 1.5 mit der Stift- und Füllfarbe "yellow".
Verwende die Befehle setFillColor("yellow"), setPenColor("yellow"), startPath() und fillPath().
Setze vor dem Zeichnen des Sterns die Füll- und Stiftfarbe auf "yellow". Rufe startPath() auf, bevor du die Sternform zeichnest. Nach dem Zeichnen aller 5 Zacken rufst du fillPath() auf.
Erstelle die Treppe aus 12 Quadraten (Seitenlänge 20) mit Hilfe einer verschachtelten Schleife.
Verwende eine äussere Schleife für die 12 Stufen und eine innere Schleife, die ein Quadrat zeichnet (for i in range(4): fd(20); rt(90)). Nach jedem Quadrat musst du die Turtle um 20 nach oben und 20 nach rechts verschieben (mit penUp()/penDown()).
Schreibe ein möglichst kurzes Programm für die abgebildete Melodie. Nutze verschachtelte Schleifen, um sich wiederholende Teile abzukürzen.
Frequenzen: c'=261, d'=293, e'=329, f'=349, g'=391, a'=440, h'=493, c''=523. Viertel=500ms, Halbe=1000ms.
Analysiere die Melodie: Gibt es Taktgruppen, die sich wiederholen? Wenn sich z.B. ein 4-Ton-Muster zweimal wiederholt, kannst du es in eine Schleife packen.
Mit dem Befehl dot(d) kann man einen ausgefüllten Kreis mit Durchmesser d zeichnen. Schreibe ein Programm, welches das Muster für d=15 zeichnet. Der Abstand der Kreise beträgt 25. Das Muster besteht aus 4 Reihen mit je 12 abwechselnd roten und blauen Punkten.
Verwende eine verschachtelte Schleife: Die äussere für die 4 Reihen, die innere für die 12 Punkte pro Reihe. Wechsle die Farbe mit setPenColor("red") und setPenColor("blue") bei jedem Punkt.
Was wird mit den beiden Programmen gezeichnet? Skizziere die Ausgaben.
Programm (a):
from gturtle import *
makeTurtle()
for i in range(4):
for j in range(4):
fd(100)
rt(90)
rt(90)
Programm (b):
from gturtle import *
makeTurtle()
ht()
for i in range(3):
rt(30)
for j in range(3):
fd(100)
rt(120)
rt(90)
(a): Die innere Schleife zeichnet ein Quadrat (4×100, 90°-Drehung). Die äussere Schleife wiederholt das 4-mal, wobei sich die Turtle nach jedem Quadrat um 90° dreht.
(b): Die innere Schleife zeichnet ein gleichseitiges Dreieck. Nach jedem Dreieck dreht sich die Turtle um insgesamt 30°+90°=120°. Drei Dreiecke mit 120° Versatz...
3. Der modulare Entwurf
Neue Begriffe: Mit def definieren wir eigene Befehle (Funktionen). Diese können beliebig oft aufgerufen werden.
Erstelle einen Befehl dreieck(), der ein regelmässiges Dreieck mit einer Seitenlänge von 100 erstellt. Verwende diesen Befehl, um das Sechseck (b) zu zeichnen – bestehend aus 6 Dreiecken.
Definiere def dreieck(): mit for i in range(3): fd(100); lt(120). Für das Sechseck: Zeichne 6 Dreiecke, die sich um eine gemeinsame Ecke drehen. Nach jedem Dreieck drehst du die Turtle um 360/6 = 60° nach links.
Schreibe je ein Programm für die zwei Grafiken (ein Spirograph-ähnliches Muster und ein Sechseck-Muster). Definiere für die Bausteine der Grafiken eigene Befehle, wobei du die Seitenlängen und Farben selber wählen kannst.
Für die erste Grafik (Spirograph): Definiere einen Baustein (z.B. ein Quadrat oder Kreis) und wiederhole ihn viele Male mit kleiner Drehung dazwischen.
Für die zweite Grafik (Sechseck-Muster): Definiere ein Sechseck als Baustein und ordne mehrere davon in einem Muster an.
Erstelle die Grafik (a) – eine Sonne mit fünfzackigen Sternen – oder eine Flagge Deiner Wahl, welche einen fünfzackigen Stern enthält (z.B. Kamerun, Surinam, Kuba). Definiere ebenfalls eigene Befehle für die Grundbausteine.
Definiere zuerst einen Befehl stern() für den fünfzackigen Stern (siehe Aufgabe 1.5). Für eine Flagge: Zeichne zuerst das Rechteck mit startPath()/fillPath() für die farbigen Streifen, dann den Stern in der richtigen Position.
Zeichne die Ausgabe des folgenden Programms ins Gitter (Papieraufgabe). Probiere es danach im Editor aus.
from gturtle import *
def teil():
for i in range(3):
fd(30)
rt(90)
lt(180)
################
makeTurtle()
ht()
for i in range(4):
teil()
Gehe den Befehl teil() Schritt für Schritt durch: 3-mal (vorwärts 30, rechts 90°), dann links 180°. Das zeichnet drei Seiten eines Quadrats und dreht sich dann um. Überlege, wo die Turtle nach jedem Aufruf von teil() steht.
Für ein Online-Schachspiel soll ein Schachbrett programmiert werden mit einer Feldgrösse von 30.
- Erstelle die Befehle
quadS()undquadW()für ein schwarzes/weisses Quadrat. - Verwende die beiden Befehle in einem neuen Befehl
reihe(), der eine Reihe zeichnet. - Verwende
reihe(), um mit dem Befehlschachbrett()das ganze Schachbrett zu zeichnen.
Definiere quadS() mit schwarzer Füllfarbe und quadW() mit weisser Füllfarbe, jeweils als gefülltes Quadrat (30×30) mit startPath()/fillPath(). Eine Reihe besteht aus 4× (schwarz + weiss). Das Schachbrett besteht aus 8 alternierenden Reihen.
Erstelle einen Befehl baum1(), der einen Baum mit Stamm und zwei Ästen mit Länge 20 zeichnet. Der Winkel zwischen den Ästen beträgt 60°.
Erstelle einen neuen Befehl baum2(), der den Baum erweitert um einen Stamm mit Länge 30 und den Befehl baum1() für die Äste verwendet.
Entwickle auf gleiche Weise den Befehl baum3() mit Stammlänge 40.
baum1(): Vorwärts 20 (Stamm), dann links 30°, vorwärts 20 (Ast), zurück 20, rechts 60°, vorwärts 20 (Ast), zurück 20, links 30°, zurück 20.
baum2(): Vorwärts 30 (Stamm), links 30°, baum1(), rechts 60°, baum1(), links 30°, zurück 30.
Erstelle einen Befehl blatt() aus dem Programmcode für ein Blütenblatt. Verwende den Befehl, um eine Blume zu zeichnen (die auch gefärbt sein kann).
# Code fuer ein Bluetenblatt:
for i in range(30):
forward(6)
rt(4)
rt(60)
for i in range(30):
forward(6)
rt(4)
Packe den Code in einen Befehl def blatt():. Eine Blume besteht aus mehreren Blättern, die gleichmässig um den Mittelpunkt verteilt sind. Z.B. 12 Blätter mit 360/12 = 30° Drehung dazwischen.
Definiere die Befehle kurz() und lang() und verwende diese, um wiederum Befehle für die Buchstaben S() und O() zu definieren. Erzeuge damit die Notnachricht SOS SOS SOS.
Zeiten: kurz=200ms, lang=600ms. Pause zwischen Symbolen=100ms, zwischen Buchstaben=600ms, zwischen Wörtern=1200ms.
kurz(): playTone(800, 200) + delay(100). lang(): playTone(800, 600) + delay(100).
def S(): kurz(); kurz(); kurz(); delay(500). def O(): lang(); lang(); lang(); delay(500).
Dann: S(); O(); S(); delay(600); S(); O(); S(); delay(600); S(); O(); S() – oder mit einer Schleife!
4. Animationen
Neue Befehle: delay(t) – wartet t Millisekunden. clear() – löscht alle Grafiken. savePlayground() – speichert den Hintergrund im Bildbuffer.
Schreibe ein Programm, mit dem die Figur – bestehend aus acht regelmässigen 6-Ecken – um den Mittelpunkt gedreht wird (Animation).
Definiere einen Befehl sechseck(): for i in range(6): fd(s); rt(60). Zeichne dann 8 Sechsecke mit 360/8 = 45° Drehung dazwischen. Für die Animation: Zeichne die Figur, warte mit delay(), lösche mit clear(), drehe leicht, wiederhole.
Schreibe ein Programm, das ein gleichseitiges Dreieck horizontal vom linken Bildschirmrand zum rechten Bildschirmrand bewegt.
Mit setPos(-450, 0) kannst du die Startposition der Turtle horizontal um 450 Pixel nach links verschieben.
Definiere einen Befehl dreieck() für das gleichseitige Dreieck. In einer Schleife: Zeichne das Dreieck, warte kurz (delay(30)), lösche (clear()), verschiebe die Turtle ein Stück nach rechts.
Ein Programm soll ein drehendes Rad mit Reifen und Felgen zeichnen.
a) Definiere zuerst einen Befehl reifen(). Lege mit dot(d) eine weisse Kreisfläche über eine schwarze. Reifen-Durchmesser: 260 (aussen schwarz), 220 (innen weiss).
b) Erstelle einen Befehl felge(), welche die graue runde Felge mit den Querstreben und dem kleinen schwarzen Kreis zeichnet. Felge: 220 (aussen grau), 200 (innen weiss). Breite der Felgen-Streben: 10, Durchmesser des schwarzen Kreises: 30.
c) Der Befehl rad() besteht nun aus reifen() und felge(). Erstelle mit rad() die Animation so, dass sich das Rad in 3 Sekunden einmal dreht.
reifen(): setPenColor("black"); dot(260); setPenColor("white"); dot(220)
felge(): Zeichne zuerst den grauen Kreis dot(220), dann den weissen dot(200), dann die Streben mit setPenWidth(10), dann den schwarzen Punkt in der Mitte.
Animation: 360° in 3 Sekunden = ca. 6° pro Frame bei 50ms delay.
Erstelle ein Programm für eine Sekunden-Stoppuhr. Verwende das Zifferblatt aus Aufgabe 2.7b und definiere einen Befehl zifferblatt() sowie einen Befehl zeiger() für einen roten Sekundenzeiger.
Für die Animation kann das Zifferblatt im Hintergrund mit savePlayground() gespeichert werden.
Optional: Füge zusätzlich einen Minutenzeiger hinzu.
Zeichne zuerst das Zifferblatt und speichere es mit savePlayground(). In der Animations-Schleife (60 Durchläufe): Zeichne den roten Zeiger, warte 1000ms, lösche mit clear() (das Zifferblatt bleibt erhalten!), drehe den Zeiger um 6°.
a) Ein kleiner Satellit soll um einen Planeten (grün) kreisen. Erstelle je einen Befehl für beide Objekte.
b) Erweitere das Programm mit einem weiteren Satelliten, der sich in die gleiche Richtung um den Planeten dreht.
(a): Zeichne den Planeten in der Mitte (mit savePlayground() fixieren). Der Satellit kreist, indem du in einer Schleife den Satelliten zeichnest, wartest, löschst, und die Turtle auf der Kreisbahn weiterbewegst.
(b): Starte den zweiten Satelliten an einer anderen Position auf der Kreisbahn (z.B. 180° versetzt) und bewege beide in jedem Animationsschritt.
5. Befehle mit Parametern
Neue Syntax: Mit def befehl(parameter): definieren wir Befehle mit Parametern, denen beim Aufruf Werte übergeben werden können. Z.B. stern(50) oder stern(100).
a) Definiere einen Befehl treppe(n) der eine Treppe mit n Stufen der Breite 20 und Höhe 15 zeichnet.
b) Eine Treppe ist 300 Pixel breit und 200 Pixel hoch. Definiere treppe(n) so, dass die Länge und Höhe der Stufen in Abhängigkeit der Anzahl n berechnet und gezeichnet werden.
(a): Jede Stufe besteht aus forward(15) und right(90), forward(20), left(90). Wiederhole das n-mal mit for i in range(n):.
(b): Berechne die Stufenhöhe als 200/n und die Stufenbreite als 300/n.
Definiere einen Befehl vieleck(n, seite, farbe, dicke) der ein regelmässiges n-Eck mit der Seitenlänge seite und der Farbe farbe und Stiftdicke dicke zeichnet.
Erstelle damit eine Folge von Vielecken mit aufsteigender Eckenzahl.
Verwende setPenColor(farbe), setPenWidth(dicke) und for i in range(n): forward(seite); right(360/n). Zeichne z.B. ein Dreieck, Quadrat, Fünfeck, Sechseck nebeneinander.
Definiere einen Befehl vieleck(n, seite) und erstelle damit eine Parkettierung (Flächenmuster) mit möglichst wenig Zeilen.
Tipp: Reguläre Parkettierungen sind mit Dreiecken, Quadraten und Sechsecken möglich.
Eine einfache Parkettierung mit Quadraten: Zeichne Reihen von Quadraten. Für Sechsecke: Jede zweite Reihe muss versetzt werden. Verwende penUp()/penDown() zum Positionieren.
Ergänze das Programm mit einem Befehl gitter(m, n, seite) der ein m × n-Gitter (m Zeilen und n Spalten) aus Quadraten mit der Seitenlänge seite zeichnet.
Definiere quadrat(seite) und reihe(n, seite). Der Befehl gitter(m, n, seite) zeichnet m Reihen untereinander. Nach jeder Reihe muss die Turtle zurück zum Anfang und eine Zeile nach unten.
Definiere einen Befehl stern(n, seite, farbe) der einen n-zackigen Stern mit der gegebenen Seitenlänge und Farbe zeichnet. Zeichne damit eine Reihe von Sternen mit 5, 6, 7 und 8 Zacken nebeneinander.
Ein n-zackiger Stern entsteht durch n Linien mit Drehwinkel 180 - 180/n Grad. Verwende setPenColor(farbe) und for i in range(n): forward(seite); right(180 - 180/n).
Definiere einen Befehl kreis(radius, farbe) der einen gefüllten Kreis mit dem gegebenen Radius und der Farbe zeichnet.
Zeichne damit eine Zielscheibe aus 5 konzentrischen Kreisen mit abwechselnden Farben (z.B. rot und weiss). Beginne mit dem grössten Kreis!
Tipp: Einen Kreis mit Radius r erhältst du mit for i in range(360): und der Seitenlänge 2 · π · r / 360.
Beginne mit dem grössten Kreis (z.B. radius=100) und zeichne immer kleinere darüber. Verwende startPath()/fillPath() mit setFillColor(farbe). Alternativ: dot(2*radius) zeichnet einen gefüllten Kreis.
Definiere einen Befehl spirale(n, start, zunahme, winkel) der eine Spirale aus n Segmenten zeichnet. Die Startlänge beträgt start und jedes Segment ist um zunahme länger als das vorherige. Der Drehwinkel beträgt winkel Grad.
Teste mit verschiedenen Werten, z.B.:
spirale(50, 5, 3, 90)– rechtwinklige Spiralespirale(100, 2, 1, 60)– sechseckige Spiralespirale(200, 1, 0.5, 91)– runde Spirale
Verwende eine Variable laenge = start. In der Schleife: forward(laenge), right(winkel), dann laenge += zunahme.
6. Variablen
Neue Konzepte: Mit input() können Werte eingegeben und in Variablen gespeichert werden. Mit += können Variablenwerte verändert werden.
Für ein Spiel sollen Spielfiguren nebeneinander gezeichnet werden. Die gewünschte Farbe und die Anzahl Spielfiguren sollen eingegeben werden können. Ergänze das Hauptprogramm mit den entsprechenden Anweisungen.
from gturtle import *
def spielfigur(farbe):
setPenColor(farbe)
setPenWidth(2)
dot(30)
fd(25)
dot(22)
bk(25)
rt(30)
bk(30)
bk(30)
fd(30)
fd(30)
lt(60)
bk(30)
bk(30)
fd(30)
rt(30)
##################
makeTurtle()
ht()
...
...
Verwende farbe = input("Farbe?") und anzahl = input("Anzahl?"). Dann in einer Schleife for i in range(anzahl): spielfigur(farbe) aufrufen und die Turtle dazwischen verschieben.
Schreibe ein Programm, welches eine Spirale aus 42 Strecken zeichnet, bei der die Seitenlängen um jeweils 3 Pixel zunimmt. Die kleinste Startseite beträgt 10 Pixel.
Verwende eine Variable seite = 10. In der Schleife: forward(seite), right(90), dann seite += 3.
Ein Programm zeichnet eine Figur, die aus n gleichseitigen Dreiecken besteht, deren Seitenlänge linear abnehmen. Das grösste Dreieck hat immer die Seitenlänge 200 und n soll eingegeben werden können.
Berechne die Abnahme als 200/n. Verwende eine Variable seite = 200. In der Schleife: Zeichne ein Dreieck mit for j in range(3): forward(seite); right(120), dann seite -= 200/n.
Schreibe ein Programm für eine Figur aus vierzig Quadraten deren Seitenlängen um 3% abnehmen und um 10° verdreht gezeichnet werden. Die Seitenlänge des grössten Quadrats beträgt 200.
Verwende seite = 200. In der Schleife: Zeichne ein Quadrat, drehe um right(10), dann seite *= 0.97.
Erstelle einen Befehl punkte(n) der eine vertikale Anordnung von n Punkten zeichnet. Beim Programmstart soll anzahl eingegeben werden können, um die Höhe der höchsten Punktspalte zu bestimmen. Daraus soll dann eine aufsteigende und absteigende Grafik gezeichnet werden (1, 2, 3, ..., n, ..., 3, 2, 1).
Definiere def punkte(n): und zeichne n Punkte mit dot(d) übereinander. Im Hauptprogramm: Zeichne Spalten mit 1 bis anzahl Punkten, dann wieder absteigend.
Schreibe ein Programm welches die Europaflagge zeichnet. Mit dem Befehl heading(0) kann die Turtle senkrecht (in Richtung Norden) ausgerichtet werden.
Zeichne zuerst das blaue Rechteck als Hintergrund mit startPath()/fillPath(). Dann 12 gelbe Sterne im Kreis anordnen. Verwende eine Variable winkel und erhöhe sie um 360/12 = 30° pro Stern. Positioniere die Turtle mit setPos() und heading().
Was ist die Ausgabe der folgenden Programme?
Programm (a):
def berechne(x, y):
a = 2 * x
b = a + 3 * y
b += a
print(b)
berechne(2, 3)
Programm (b):
x = 1
zahl = 0
for i in range(4):
zahl *= 10
zahl += x
print(zahl)
(a): x=2, y=3: a = 2*2 = 4, b = 4 + 3*3 = 13, b += 4 → b = 17. Ausgabe: 17.
(b): Durchlauf 1: zahl = 0*10+1 = 1. Durchlauf 2: zahl = 1*10+1 = 11. Durchlauf 3: zahl = 11*10+1 = 111. Durchlauf 4: zahl = 111*10+1 = 1111. Ausgabe: 1, 11, 111, 1111.
Schreibe einen Befehl ungerade(n) der die ersten n ungeraden Zahlen ausgibt. (z.B. ungerade(4) gibt aus: 1, 3, 5, 7)
Verwende eine Variable x = 1. In der Schleife: print(x), dann x += 2. Alternativ: print(2*i - 1) mit i von 1 bis n.
Schreibe einen Befehl quadratzahl(n) der alle Quadratzahlen der ersten n natürlichen Zahlen ausgibt. n soll eingegeben werden können. (z.B. quadratzahl(5) gibt aus: 1, 4, 9, 16, 25)
Verwende eine Variable x = 1. In der Schleife: print(x * x), dann x += 1.
Schreibe einen Befehl sum(n) der die Summe der ersten n natürlichen Zahlen berechnet und ausgibt. (Beispiel: sum(4) gibt aus: 10, weil 1 + 2 + 3 + 4 = 10)
Verwende eine Variable summe = 0 und x = 1. In der Schleife: summe += x, dann x += 1. Am Ende: print(summe).
Schreibe ein Programm, das die Multiplikationstabelle für eine eingegebene Zahl n ausgibt.
Beispiel für n=7:
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 ... 7 * 10 = 70
Verwende n = input("Zahl eingeben"). In der Schleife for i in range(1, 11): gib aus: print(n, "*", i, "=", n*i).
Schreibe ein Programm, das 5 Zahlen nacheinander einliest und für jede Zahl einen horizontalen Balken zeichnet, dessen Länge dem eingegebenen Wert entspricht. Beschrifte jeden Balken mit der Zahl.
Tipp: Verwende input() in einer Schleife und zeichne den Balken mit der Turtle.
In der Schleife: wert = input("Zahl?"). Zeichne einen Balken mit setPenWidth(20) und forward(wert). Positioniere die Turtle für den nächsten Balken.
Die Fibonacci-Folge beginnt mit 1, 1 und jede weitere Zahl ist die Summe der beiden vorherigen: 1, 1, 2, 3, 5, 8, 13, 21, ...
Schreibe einen Befehl fibonacci(n) der die ersten n Fibonacci-Zahlen ausgibt. Zeichne zusätzlich mit der Turtle für jede Fibonacci-Zahl ein Quadrat mit der entsprechenden Seitenlänge, sodass eine «Fibonacci-Spirale» entsteht.
Verwende zwei Variablen a = 1, b = 1. In der Schleife: print(a), zeichne Quadrat mit Seitenlänge a, dann temp = b, b = a + b, a = temp.
Bearbeite die Projektaufgabe Analoguhr in der eine animierte Uhr mit Sekunden-, Minuten- und Stundenzeigern entwickelt werden soll, welche die aktuelle Uhrzeit anzeigt.
Verwende dein Zifferblatt aus Aufgabe 2.7 und speichere es mit savePlayground(). Berechne die Zeigerwinkel aus der aktuellen Zeit. Der Sekundenzeiger dreht sich um 6° pro Sekunde, der Minutenzeiger um 6° pro Minute, der Stundenzeiger um 30° pro Stunde.