DU LERNST HIER...

PROGRAMMSTRUKTUR SEQUENZ

Ein Computerprogramm besteht aus einer Folge von Programmzeilen, die der Reihe nach (als Sequenz) abgearbeitet werden. Damit du die Käferbefehle verwenden kannst, musst du mit from cpglow import * das Modul cpglow importieren.

Mit dem Befehl makeGlow() erzeugst du einen sichtbaren Käfer in der Mitte des Displays. Es ist eine einzelne leuchtende LED. Bei einer Bewegung des Käfers werden LEDs an den besuchten Positionen eingeschaltet, er hinterlässt also sozusagen eine Spur. Deine Befehle werden nach dem Herunterladen des Programms auf den Calliope ausgeführt.

Die Befehle werden grundsätzlich Englisch geschrieben und enden immer mit einer Parameterklammer. Diese kann weitere Angaben für den Befehl enthalten. Die Gross-/Kleinschreibung musst du exakt einhalten.

Mit forward() bewegt sich der Käfer einen Schritt vorwärts in der aktuellen Bewegungsrichtung. Bei Programmstart zeigt die Bewegungsrichtung nach oben. Mit left(90) dreht der Käfer um 90 Grad nach links und mit right(90) um 90° nach rechts. Dies macht sich aber erst beim nächsten forward()-Befehl bemerkbar.

Mit deinem Programm zeichnet der Käfer die daneben abgebildete Spur:

from cpglow import * makeGlow() forward() left(90) forward() right(90) forward() from cpglow import * makeGlow() forward() left(90) forward() right(90) forward() ► In Zwischenablage kopieren

WIEDERHOLUNG MIT REPEAT

Du willst ein möglichst grosses Quadrat zeichnen. Dazu setzt du mit setPos(-2, -2) den Käfer in die linke untere Ecke. Mit setPos(x, y) wird also der Käfer an eine beliebige neue Position gesetzt. Damit er sichtbar ist, musst du für x und y -2, -1, 0, 1 oder 2 wählen. Um eine Quadratseite zu zeichnen, bewegst du den Käfer 4 mal vorwärts. Auch für diese 4 Vorwärtsschritte kannst du eine repeat-Schleife verwenden. Dein Programm hat also zwei ineinander geschachtelte repeat-Schleifen.

Achte auf eine korrekte Einrückung!

from cpglow import *

makeGlow()

setPos(-2, -2)
repeat 4:
    repeat 4:
        forward()
    right(90)

FUNKTIONEN (BENANNTE PROGRAMMBLÖCKE)

Mit benannten Programmblocks, in Python Funktionen genannt, machst du deine Programme übersichtlicher. Zudem kannst du Funktionen mehrmals aufrufen. Die Verwendung von Funktionen ist von grosser Wichtigkeit, denn du vermeidest dadurch, dass du gleichen Code mehrmals im Programm hinschreiben musst (Codeduplikation)  und du kannst Probleme in kleinere Probleme zerlegen.

In deinem Beispiel definierst du eine Funktion square(), die den Käfer auf einem Quadrat bewegt. Die Funktionsdefinition beginnt mit dem Keyword def. Dann folgen der Funktionsname, eine Parameterklammer und ein Doppelpunkt. . Die Befehle im Funktionskörper müssen eingerückt sein. Beachte, dass die Befehle erst beim Funktionsaufruf ausgeführt werden. Die Funktionsdefinitionen stehen jeweils im oberen Teil des Programms.

Wähle als Funktionsnamen einen Bezeichner, dass etwas darüber aussagt, was die Funktion macht. Du darfst keine Spezialzeichen (Leerschläge, Umlaute, Akzente, Satzzeichen, usw.) verwenden. Beginne den Namen immer mit einem kleinen Buchstaben. Im folgenden Programm definierst du eine Funktion square(), die ein Quadrat zeichnet, und führst sie dann aus.

from cpglow import *

makeGlow()

def square():
    repeat 4:
        forward()
        forward()
        left(90)

square()

Mit der Definition von square() hast du sozusagen einen neuen Befehl eingeführt, den du nun beliebig oft verwenden kannst.. Um das nebenstehende Bild zu erzeugen rufst du die Funktion square() 4-mal auf. Mit dem Befehl setSpeed(80) läuft den Käfer schneller. (Der Standardwert ist 50 und es sind Werte im Bereich 0 bis 100 erlaubt.)

from cpglow import *

makeGlow()

def square():
    repeat 4:
        forward()
        forward()
        left(90)

setSpeed(80)
repeat 4:
    square()
    right(90)

VARIABLEN

In der Informatik sind Variablen Platzhalter für Werte, die sich im Laufe der Programmausführung ändern. v ist die Geschwindigkeit des Käfers. Mit v = 30 setzst du v auf den Anfangswert 30.  Man nennt diesen Befehl eine Zuweisung. Dieser wird nach jedem durchgelaufenen Quadrat um 20 vergrössert.

Dazu verwendest du den Befehl v = v + 20, der auf den ersten Blick wie eine unsinnige Gleichung aussieht, aber dem Computer sagt, er soll den bestehenden Wert von v holen und 20 dazu zählen, und nachher das Resultat wieder in v abspeichern. Der Befehl showTrace(False) bewirkt, dass der Käfer keine Spuren hinterlässt.

from cpglow import *

makeGlow()

def square():
    repeat 4:
        forward()
        forward()
        right(90)
    
v = 30
showTrace(False)
setPos(-1, -1)

repeat 4:
    setSpeed(v)
    square()
    v = v + 20

WIEDERHOLUNG MIT WHILE

Die while-Schleife ist eine der wichtigsten Programmstrukturen überhaupt. Sie kann allgemein für jede Art von Wiederholungen verwendet werden und kommt in praktisch allen Programmiersprachen vor. Eine while-Schleife wird mit dem Schlüsselwort while eingeleitet gefolgt von einer Bedingung und einem Doppelpunkt. So lange die Bedingung erfüllt ist, werden die Befehle im nachfolgenden Programmblock wiederholt. Umgangssprachlich würde man dies wie folgt ausdrücken:

Solange die Bedingung wahr, führe aus ...

In der Bedingung werden  in der Regel die Vergleichsoperatoren < (kleiner), <= (kleiner-gleich), > (grösser)  >= (grösser-gleich), == (gleich), != (verschieden) verwendet. Beachte die Verdoppelung des Gleichheitszeichens beim Test auf Gleichheit (damit es nicht mit einer Zuweisung verwechselt wird).

In deinem Beispiel bewegt sich der Käfer zuerst 2 Schritte vorwärts, dann 2 Schritte rückwärts, dreht um 45°, danach wieder 2 Schritte vorwärts usw., so lange, bis er wieder gegen Norden schaut. Den Gesamtdrehwinkel speicherst du in der Variablen a. Du beginnst mit a = 0 und zählst nach jedem Schleifendurchgang 45 dazu. So lange die Bedingung a <= 360 stimmt, werden die eingerückten Anweisungen ausgeführt.

from cpglow import *

makeGlow()

setSpeed(90)
showTrace(False)
a = 0
while a <= 360:
    forward()
    forward()
    back()
    back()
    left(45)    
    a = a + 45

In der Robotik wird häufig eine sogenannte "endlose while-Schleife" verwendet. Diese wird mit while True: eingeleitet. Da True immer wahr ist, wird die Schleife so lange ausgeführt, bis du die Programmausführung im nebenstehenden Konsolenfenster mit Ctrl+C beendest oder die Spannungsversorgung des Calliope unterbrichst. clear() löscht alle LEDs.

from cpglow  import *

makeGlow()

def square():
    repeat 4:
        forward()
        forward()
        left(90)

clear()
setSpeed(90)
showTrace(False)
setPos(2, 0)
left(45)
while True:
    square()

WIEDERHOLUNG MIT FOR IN RANGE

Oft brauchst du in einer Wiederholschleife eine ganzzahlige Variable, die bei jedem Durchgang um eins grösser wird. Du kannst dies zwar mit einer while-Schleife lösen, einfacher geht es aber mit einer for-Schleife, bei welcher der Schleifenzähler automatisch verändert wird. for i in range(n) durchläuft Zahlen i von 0 bis n-1 for i in range(a, b) durchläuft Zahlen i von a bis b-1 Beachte, dass der Endwert n bzw. b nie enthalten ist.

Mit for x in range(-2, 3) durchläuft also x die Werte -2, -1, 0, 1, 2. Dabei werden die LEDs in der obersten Reihe nacheinander eingeschaltet. Mit sleep(500) kannst du die Programmausführung 500 Millisekunden anhalten, damit du den Ablauf besser beobachten kannst.

from cpglow import *

makeGlow()

clear()
for x in range(-2, 3):
    setPos(x, 2)
    sleep(500)

IF - ELSE - STRUKTUR (SELEKTION)

Mit der Selektion kannst du bewirken, dass bestimmte Programmblöcke nur unter gewissen Bedingungen ausgeführt werden. Die Selektion wird mit dem Schlüsselwort if eingeleitet, gefolgt von einer Bedingung. Die Anweisungen im if werden nur dann ausgeführt, wenn die Bedingung wahr ist, sonst werden die Anweisungen nach else ausgeführt. In der if-Bedingung werden üblicherweise die Vergleichsoperatoren >, >= , < , <= , == , != verwendet. Die Anweisungen im if- bzw. else-Block müssen eingerückt sein. Der else-Teil kann auch wegfallen.

In diesem Beispiel bewegt sich der Käfer nach rechts. Wenn er am rechten Rand angekommen ist, springt er wieder zum linken Rand und wiederholt diese Bewegung von links nach rechts endlos. Du bewegst also den Käfer mit forward() nach rechts und überprüfst nach jedem Schritt seine x-Koordinate. Wenn sie 3 ist, so wird der Käfer wieder auf den linken Rand versetzt (x = -2).

from cpglow import *
makeGlow()

right(90)
x = 0
showTrace(False) 

while True:
    forward()
    x = x + 1  
    if x == 3:
        setPos(-2, 0)        
        x = -2 

Im nächsten Programm soll der Käfer zufällig zwei Schritte vorwärts oder zwei Schritte rückwärts laufen, dann kurz anhalten, die Spur löschen und an die Anfangsposition zurückkehren. Diese Bewegung soll er 10 Mal wiederholen.

Du verwendest Zufallszahlen. Die Funktion randint(a, b) aus dem Modul random erzeugt zufällig eine ganze Zahl zwischen a und bis und mit b. Daher liefert die Funktion randint(0, 1) zufällig eine 0 oder eine 1. Ist der Wert 1, so läuft der Käfer 2 Schritte vorwärts, sonst (wenn die Zahl 0 ist) 2 Schritte rückwärts.

from cpglow import *
from random import randint

makeGlow()
setSpeed(80)
repeat 10:    
    r = randint(0, 1)
    if r == 1:
        forward()
        forward()
    else:
        back()
        back()     
    sleep(300)
    clear()
    setPos(0, 0) 

MERKE DIR...

Die grundlegenden Programmstrukturen sind  Sequenz, Wiederholung und Selektion. Bei einer Sequenz werden die Befehle der Reihe nach abgearbeitet. Mit einer Wiederholung werden Programmblocks mehrmals ausgeführt. Im TigerJython kannst du dazu die repeat-; while- oder for-Schleifen verwenden. Die Selektion mit if und else bewirkt, dass bestimmte Anweisungen nur unter gewissen Bedingungen ausgeführt werden. Der else-Teil kann auch entfallen.

ZUM SELBST LÖSEN