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: Für Wiederholungen gibt es zwei Schreibweisen: repeat n: (TigerJython) und for i in range(n): (Python). Du kannst oben rechts zwischen beiden umschalten.
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.
Mit drawImage("sprites/marble_1.png") lässt sich der grüne Planet aus der Bilddatenbank einfügen.
b) Erweitere das Programm mit einem weiteren Satelliten, der sich in die gleiche Richtung um den Planeten dreht.
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 aus Beispiel 5.3 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.
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 repeat 360: und der Seitenlänge 2 · π · r / 360.
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
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.
7. Robotik mit dem Maqueen
Der Maqueen Plus V2 ist ein kleiner Roboter, der mit einem micro:bit gesteuert wird. Der micro:bit ist sozusagen das Gehirn des Roboters: Wir flashen unser Python-Programm auf den micro:bit, stecken ihn in den Maqueen, und schon können wir Motoren ansteuern, Sensoren auslesen und Linien folgen lassen.
Am Anfang jedes Programms importierst du die passende Bibliothek mit from mbrobot_plusV2 import *.
Bewegungsbefehle
| Befehl | Wirkung |
|---|---|
forward() | bewegt den Roboter vorwärts |
backward() | bewegt den Roboter rückwärts |
left() | dreht nach links |
right() | dreht nach rechts |
leftArc(radius) | bewegt sich auf einem Linksbogen |
rightArc(radius) | bewegt sich auf einem Rechtsbogen |
setSpeed(speed) | ändert die Geschwindigkeit (Standard 50) |
motR.rotate(speed) | setzt die Geschwindigkeit nur des rechten Motors |
motL.rotate(speed) | setzt die Geschwindigkeit nur des linken Motors |
stop() | hält beide Motoren an |
Sensoren- und Aktorenbefehle
| Befehl | Wirkung |
|---|---|
getDistance() | Abstand zum nächsten Objekt vor dem Ultraschallsensor in cm |
irL2.read_digital() | äusserer linker Infrarotsensor: 0 = schwarz, 1 = weiss |
irL1.read_digital() | innerer linker Infrarotsensor |
irM.read_digital() | mittlerer Infrarotsensor |
irR1.read_digital() | innerer rechter Infrarotsensor |
irR2.read_digital() | äusserer rechter Infrarotsensor |
setServo('S2', 90) | Servomotor an Anschluss S2 auf 90° drehen |
Die komplette Befehlsreferenz findest du in der offiziellen Maqueen-Dokumentation auf tigerjython.ch.
Das folgende Programm lässt den Roboter ein Quadrat fahren. Zwischen den Befehlen warten wir mit delay() einige hundert Millisekunden, damit der Roboter die Bewegung überhaupt ausführen kann, bevor der nächste Befehl kommt.
from mbrobot_plusV2 import *
setSpeed(50)
repeat 4:
forward()
delay(800)
right()
delay(400)
stop()
So gehst du vor: Programm in WebTigerPython einfügen, micro:bit per USB anschliessen, «Flash» klicken, micro:bit in den Maqueen stecken – und am Schalter einschalten.
Für die Linienverfolgung verwendet der Roboter die Infrarotsensoren auf seiner Unterseite. Schwarze Flächen absorbieren das Infrarotlicht – die Sensoren liefern dann eine 0. Weisse Flächen reflektieren das Licht und liefern eine 1.
Tipp: Falls die Sensoren unerwartete Werte liefern, stelle den Roboter auf eine schwarze Fläche und halte die Kalibrierungstaste am Roboter gedrückt.
Der Maqueen Plus V2 hat fünf Infrarotsensoren. Fürs erste Verstehen reichen die beiden inneren Sensoren irL1 und irR1:
from mbrobot_plusV2 import *
repeat:
links = irL1.read_digital()
rechts = irR1.read_digital()
print(links, rechts)
sleep(200)
Das Programm liest die beiden inneren Sensoren aus, gibt die Werte (0 für schwarz, 1 für weiss) in der Konsole aus und wartet danach 200 Millisekunden bis zur nächsten Messung.
Für eine genauere und schnellere Linienverfolgung kannst du alle fünf Infrarotsensoren gleichzeitig nutzen. Sie heissen von links nach rechts irL2, irL1, irM, irR1, irR2:
from mbrobot_plusV2 import *
repeat:
links_aussen = irL2.read_digital()
links = irL1.read_digital()
mitte = irM.read_digital()
rechts = irR1.read_digital()
rechts_aussen = irR2.read_digital()
print(links_aussen, links, mitte, rechts, rechts_aussen)
sleep(200)
Vorne am Roboter sitzt ein Ultraschallsensor. Mit getDistance() bekommst du den Abstand zum nächsten Objekt in Zentimetern zurück.
Eine einfache Strategie für ein Labyrinth ist die Rechte-Hand-Regel: Der Roboter hält die «Hand» (also den Sensor) an der rechten Wand. Mit dem folgenden Programmskelett startest du eine simple Hindernisvermeidung:
from mbrobot_plusV2 import *
setSpeed(40)
repeat:
abstand = getDistance()
print(abstand)
if abstand < 10:
left()
delay(400)
else:
forward()
sleep(100)
Für eine richtige Labyrinth-Navigation kannst du den Ultraschallsensor auch auf einen Servomotor montieren und so abwechselnd nach vorne und zur Seite schauen lassen.
Mit dem Modul radio können zwei micro:bits drahtlos miteinander reden. Damit lässt sich ein zweiter micro:bit als Fernbedienung verwenden: solange Taste A gedrückt ist, sendet die Fernbedienung "vor", solange Taste B gedrückt ist "zurueck". Ist keine Taste gedrückt, schicken wir "stopp". Damit das funktioniert, brauchst du beide Programme: das Sender-Programm auf der Fernbedienung und das Empfänger-Programm im Roboter.
1. Sender – diesen Code flashst du auf den micro:bit, den du als Fernbedienung benutzt. Er liest den Joystick (analog auf pin1/pin2) sowie alle Gamepad-Tasten aus und schickt für jede Eingabe einen kurzen Code: F/B/L/R für die Joystick-Richtungen, L1/R1 für die micro:bit-eigenen Tasten (als Schultertasten) und A/B/X/Y für die vier Frontasten. Das LED-Display zeigt jeweils die aktuelle Eingabe.
from microbit import *
import radio
radio.on()
radio.config(group=1)
# Joystick threshold
THRESHOLD_LOW = 300
THRESHOLD_HIGH = 700
repeat:
x = pin1.read_analog()
y = pin2.read_analog()
if y < THRESHOLD_LOW:
radio.send("B") # rückwärts
display.show("B")
elif y > THRESHOLD_HIGH:
radio.send("F") # vorwärts
display.show("F")
elif x < THRESHOLD_LOW:
radio.send("L") # links
display.show("L")
elif x > THRESHOLD_HIGH:
radio.send("R") # rechts
display.show("R")
elif button_a.is_pressed():
radio.send("L1") # Schultertaste links
display.show("L1")
elif button_b.is_pressed():
radio.send("R1") # Schultertaste rechts
display.show("R1")
elif pin13.read_digital() == 0:
radio.send("A")
pin13.write_digital(1)
display.show("A")
elif pin14.read_digital() == 0:
radio.send("B")
display.show("B")
pin14.write_digital(1)
elif pin15.read_digital() == 0:
radio.send("Y")
display.show("Y")
pin15.write_digital(1)
elif pin16.read_digital() == 0:
radio.send("X")
display.show("X")
pin16.write_digital(1)
sleep(100)
Der Joystick gilt als nach unten/links, wenn sein Analogwert unter 300 liegt, und als nach oben/rechts über 700. Zwischen diesen Grenzen ist er neutral – dann wird auf die Tasten geschaut. Die elif-Kette bedeutet: pro Schleifendurchlauf wird genau eine Eingabe gesendet (Joystick hat Priorität).
2. Empfänger – diesen Code flashst du auf den micro:bit, der im Maqueen steckt. Er reagiert auf die Buchstaben aus dem Sender:
from mbrobot_plusV2 import *
import radio
radio.config(group=1, power=7)
radio.on()
repeat:
nachricht = radio.receive()
if nachricht == "F":
forward()
elif nachricht == "B":
backward()
elif nachricht == "L":
left()
elif nachricht == "R":
right()
elif nachricht is not None:
stop()
sleep(50)
Wichtig: beide micro:bits müssen dieselbe group verwenden – hier 1. radio.receive() gibt None zurück, wenn gerade keine Nachricht angekommen ist; in diesem Fall macht der Roboter einfach weiter, was er zuletzt getan hat. Jede andere Nachricht ausser F/B/L/R (z. B. die Gamepad-Tasten A, X, Y, L1, R1) hält den Roboter an – damit hast du automatisch eine Notstopp-Taste.
Genau wie in Kapitel 3 mit der Schildkröte lohnt es sich, eine wiederholte Bewegung in einer eigenen Funktion zu verpacken. So kannst du mit einem einzigen Aufruf ein Quadrat, ein Dreieck oder ein Sechseck fahren lassen:
from mbrobot_plusV2 import *
def vieleck(seiten, fahrzeit, drehzeit):
repeat seiten:
forward()
delay(fahrzeit)
right()
delay(drehzeit)
setSpeed(50)
vieleck(4, 800, 400) # Quadrat
stop()
Die drehzeit bestimmt, um wie viele Grad der Roboter pro Ecke abbiegt. Den passenden Wert findest du durch Ausprobieren – je nach Batteriestand und Untergrund dreht der Maqueen unterschiedlich schnell. Mit vieleck(3, 800, 530) näherst du dich z. B. einem Dreieck an, mit vieleck(6, 500, 270) einem Sechseck.
In 7.3 hast du die fünf Sensoren des Maqueen Plus V2 ausgelesen. Jetzt lassen wir den Roboter auf die Werte reagieren. Die Idee: solange der mittlere Sensor irM die schwarze Linie sieht, fährt der Roboter geradeaus. Erkennt einer der seitlichen Sensoren irL1 oder irR1 die Linie, drosseln wir den Motor auf dieser Seite – der Roboter lenkt zurück Richtung Linie.
from mbrobot_plusV2 import *
repeat:
links = irL1.read_digital()
mitte = irM.read_digital()
rechts = irR1.read_digital()
if mitte == 0:
# mittlerer Sensor auf der Linie -> geradeaus
motL.rotate(30)
motR.rotate(30)
elif links == 0:
# linker Sensor auf Linie -> Roboter ist nach rechts abgekommen
motL.rotate(0)
motR.rotate(30)
elif rechts == 0:
# rechter Sensor auf Linie -> Roboter ist nach links abgekommen
motL.rotate(30)
motR.rotate(0)
else:
# Linie verloren -> langsam weitersuchen
motL.rotate(20)
motR.rotate(20)
sleep(20)
Mit motL.rotate und motR.rotate steuerst du jeden Motor einzeln an. Das nennt man Differentialantrieb: durch unterschiedliche Geschwindigkeiten links/rechts kann der Roboter Kurven fahren, ohne stehen zu bleiben. Den Wert 30 kannst du anpassen – grössere Zahlen bedeuten schneller, aber auch höhere Gefahr, dass der Roboter aus der Kurve fliegt.
Mit dem Ultraschallsensor lässt sich der Roboter so programmieren, dass er einen festen Abstand zu einer Hand oder einer Wand hält. Ist das Ziel zu weit weg, fährt er vor; ist es zu nah, fährt er zurück.
from mbrobot_plusV2 import *
ziel = 15 # gewuenschter Abstand in cm
repeat:
abstand = getDistance()
if abstand > ziel + 3:
forward() # zu weit weg -> naeher heran
elif abstand < ziel - 3:
backward() # zu nah -> ein Stueck zurueck
else:
stop() # im Wohlfuehlbereich
sleep(50)
Der Toleranzbereich von ±3 cm verhindert, dass der Roboter dauernd zwischen vorwärts und rückwärts zittert. Ohne diese sogenannte Hysterese würde schon das kleinste Rauschen des Sensors die Richtung wechseln lassen.
Wenn du den Ultraschallsensor auf einen Servomotor montierst, kann der Roboter den Kopf drehen und so vor jedem Schritt nach links und rechts schauen. Das folgende Programm schwenkt den Servo am Anschluss S2 in 30-Grad-Schritten von 0° bis 180° und wieder zurück:
from mbrobot_plusV2 import *
repeat:
winkel = 0
while winkel <= 180: # while funktioniert wie if, wird aber viele Male wiederholt
setServo('S2', winkel)
delay(200)
winkel = winkel + 30
winkel = 180
while winkel >= 0: # while funktioniert wie if, wird aber viele Male wiederholt
setServo('S2', winkel)
delay(200)
winkel = winkel - 30
Die 30 in winkel = winkel + 30 ist die Schrittweite. Kleinere Werte ergeben eine flüssigere Bewegung, brauchen aber länger pro Durchgang. Auch die delay(200) kannst du anpassen: kleinere Werte = schnelleres Schwenken, grössere Werte = der Servo erreicht die Position sicherer, bevor der nächste Befehl kommt.
Statt einer selbstgebauten Fernbedienung (7.5) kannst du den Maqueen auch mit einem fertigen Gamepad steuern – z. B. dem joystick:bit-Aufsatz, der einen eigenen micro:bit aufnimmt. Bevor wir das Gamepad an den Maqueen koppeln, schauen wir uns an, welche physische Taste welchen Pin anspricht. Dafür flashst du dieses Programm direkt auf den micro:bit im Gamepad (kein Roboter, kein Funk):
from microbit import *
repeat:
if button_a.is_pressed():
print("A")
if button_b.is_pressed():
print("B")
if pin12.read_digital() == 0:
print("C")
if pin13.read_digital() == 0:
print("D")
if pin14.read_digital() == 0:
print("E")
if pin15.read_digital() == 0:
print("F")
sleep(200)
Verbinde den micro:bit per USB, öffne in WebTigerPython die Konsole und drücke nacheinander die Tasten. Beim Drücken schaltet der entsprechende Pin auf 0 (Pull-up-Widerstand), und das Programm gibt den passenden Buchstaben aus. Mit dieser Zuordnung kannst du danach (wie in 7.5) eine eigene Steuerung schreiben – z. B. if button_a.is_pressed(): radio.send("vor").
Tipp: Die Pin-Zuordnung (pin12=C, pin13=D, pin14=E, pin15=F) gilt für die joystick:bit V2-Verdrahtung. Falls eine Taste nichts anzeigt, lies im Datenblatt deines Gamepads nach – andere Modelle können abweichende Pins verwenden.