TigerJython4Kids
HomeTurtlegrafikRobotikDatenbanken
memory
deutsch   english   français

PYTHON CRASH COURSE

 

 

DU LERNST HIER...

 

das Wichtigste zum Programmieren mit Python an einfachen Beispielen mit einen Leuchtkäfer (Glowbug), den du mit den Befehlen forward(), left(), right() und back() auf dem micro:bit-Display bewegen kannst. Falls du dich bereits im Kapitel Turtlegrafik in Python eingearbeitet oder äquivalente Grundkenntnisse von Python hast, kannst du dieses Kapitel überspringen und direkt zum nächsten Menüpunkt übergehen.

 

 

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 mbglow import * das Modul mbglow importieren.

Mit dem Befehl makeGlow() erzeugst du einen sichtbarer 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 eine Spur.

Deine Befehle werden nach dem Herunterladen des Programms auf den micro:bit 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 mbglow import *

makeGlow()

forward()
left(90)
forward()
right(90)
forward()
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 
Du kannst das Programm eintippen oder aus der Vorlage kopieren. Dazu klickst du auf Programmcode markieren und kopierst das Programm mit Ctrl+C in den Zwischenspeicher und fügst es mit Ctrl+V in das TigerJython-Fenster ein.

Um das Programm auf den micro:bit herunterzuladen und dort auszuführen, klickst du in der Taskleiste auf den schwarzen Button (Hinunterladen/Ausführen).

 

 

 

WIEDERHOLUNG MIT REPEAT

 

Um ein Quadrat zu durchlaufen, muss der Käfer vier Mal die Befehle forward() und left(90) ausführen. Du ersparst dir viel Schreibarbeit, wenn du eine Wiederholschleife verwendest. Du schreibst einfach repeat 4: (der Doppelpunkt ist wichtig). Die Befehle. die wiederholt werden sollen, müssen alle gleichweit einrückt sein. Du verwendest dazu vier Leerschläge oder die Tabulator-Taste.

 

from mbglow import *

makeGlow()

repeat 4:
    forward()
    left(90)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

Du willst ein möglichst grosses Quadrat zeichnen. Dazu setzt du mit setPos(-2, -2) den Käfer in die linke untere Ecke. Du kannst also mit setPos(x, y) den Käfer an eine neue Position versetzen. Für x, und y kannst du -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ärtschritte kannst du eine repeat-Schleife verwenden.

 

Achte auf eine korrekte Einrückung!

from mbglow import *

makeGlow()

setPos(-2, -2)
repeat 4:
    repeat 4:
        forward()
    right(90)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

 

FUNKTIONEN (BENANNTE PROGRAMMBLÖCKE)

 

Mit benannten Programmblocks, in Python Funktionen genannt, machst du deine Programme übersichtlicher. Du kannst selbstdefinierte Funktionen auch 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 Zeilen im Funktionskörper müssen eingerückt sein. Die Funktion wird beim Funktionsaufruf ausgeführt. 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.

from mbglow import *

makeGlow()

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

square()
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)


Eine Funktion kannst du mehrmals aufrufen. 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 mbglow import *

makeGlow()

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

setSpeed(80)
repeat 4:
    square()
    right(90)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

 

VARIABLEN

 

In der Informatik sind Variablen Platzhalter für Werte, die sich im Laufe der Programmausführung ändern. Eine Variable hat einen Namen und einen Wert.

Hier verwendest du die Variable v, die zu Beginn den Wert 30 hat ( v = 30). v ist die Geschwindigkeit des Käfers. Diese wird n jedem durchgelaufenen Quadrat um 20 grösser.

 

Mit der Zeile v = v + 20, die auf den ersten Blick wie eine Gleichung aussieht, wird der aktuelle Wert von v um 20 erhöht und das Resultat wieder in v abgespeichert. Es ist eine Zuweisung. Der Befehl showTrace(False) bewirkt, dass der Käfer keine Spuren hinterlässt.

from mbglow 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
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

 

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 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 Gleich!

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 mbglow import *

makeGlow()

setSpeed(90)
showTrace(False)
a = 0
while a <= 360:
    forward()
    forward()
    back()
    back()
    left(45)    
    a = a + 45
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)


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 micro:bit unterbrichst. clear() löscht alle LEDs.

 

from mbglow  import *

makeGlow()

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

clear()
setSpeed(90)
showTrace(False)
setPos(2, 0)
left(45)
while True:
    square()
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

 

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, wo 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 die fortlaufende LED-Einschaltung besser beobachten kannst.

from mbglow import *

makeGlow()

clear()
for x in range(-2, 3):
    setPos(x, 2)
    sleep(500)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

 

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 mbglow import *

makeGlow()

right(90)
x = 0
showTrace(False) 

while True:
    forward()
    x = x + 1  
    if x == 3:
        setPos(-2, 0)        
        x = -2 
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

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 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 Vorwärtsschritte vorwärts, sonst (wenn die Zahl 0 ist) 2 Schritte rückwärts.

 

 

from mbglow 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) 
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

 

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-Schleife verwenden. Die Selektion mit if und else bewirkt, dass bestimmte Anweisungen nur unter gewissen Bedingungen ausgeführt werden. Der else-Teil kann auch entfallen.

Funktionen sind wichtig für die strukturierte Programmierung. Sie vermeiden die Codeduplikation und dienen dazu, Probleme in kleinere Teilprobleme zu zerlegen. Man spricht auch von Modularisierung.

 

 

ZUM SELBST LÖSEN

 

 

1.
Schreibe ein Programm mit einer Wiederholstruktur repeat, so dass der Leuchtkäfer den nebenstehenden Weg abläuft.  

2a.
Setze den Käfer zuerst mit setPos(-2, -2) in die linke untere Ecke des Displays. Dann soll er sich 4 Treppenstufen hinauf bewegen.  

2b.

Löse die gleiche Aufgabe mit einer Funktion step(), die eine einzelne Stufe zeichnet und rufe sie dann mit einer repeat-Schleife 4-mal auf.

 

 

 

 

3.

Schreibe ein Programm, welches die LEDs in den beiden Diagonalen einschaltet.

 

4.

So wie im ersten Beispiel zur if-else bewegt sich der Käfer von links nach rechts. Er soll hier aber nicht nur eine Reihe, sondern alle Reihen durchlaufen. Der Käfer startet also in der linken unteren Ecke und bewegt sich nach rechts. Wenn er den rechten Rand erreicht hat, springt er wieder zum linken Rand und setzt seine Bewegung in der zweiten Reihe fort. Seine y-Koordinate wird also um 1 grösser.

 

5.

Um alle LEDs des Displays durchzulaufen, kannst du auch zwei for-Schleifen verwenden, und mit setPos(x, y) die LEDs einschalten:

for y in range(-2, 3):
    for x in range (-2, 3):
        setPos(x, y)

Dein Programm soll alle LEDs durchlaufen und LEDs gemäss der nebenstehenden Figur eingeschalten.

 

6.

Dein Programm soll LEDs gemäss der nebenstehenden "Schachbrett"-Figur einschalten. Mit ein wenig überlegen, merkst du, dass die leuchtenden LEDs folgende Bedingung erfüllen: die Summe ihrer x- und y-Koordinaten ist eine gerade Zahl. Für die Überprüfung, ob eine Zahl gerade oder ungerade ist, verwendet man in der Regel die Modulo-Division a % b, die den Rest der Division a durch b liefert. In deiner Aufgabe kann (x + y) % 2 entweder den Rest 0 oder den Rest 1 ergeben.

 
 

 

 

0-1
Didaktische Hinweise:

Das Keyword repeat gehört nicht zur Syntax von Python, sondern wurde speziell in TigerJython eingebaut, damit schon sehr früh, d.h. vor der Einführung von Variablen, Wiederholstrukturen möglich sind. Diese werden als ganz natürlich empfunden, denn auch im Alltag spricht man davon, eine Aktion n-mal zu wiederholen.

Will man zu Python kompatibel bleiben, so kann später repeat n: immer durch
for i in range(n):
ersetzt werden.

Endlosschleifen können durch Weglassen der Zahl der Wiederholungen, also mit
repeat:
eingeleitet werden.

0-4
Didaktische Hinweise:

Der Variablenbegriff ist von grundlegender Bedeutung, aber eine didaktische Herausforderung.

Es gibt im Wesentlichen drei verschiedene methodische Ansätze. Da wir bei der micro:bit-Robotik Variablen nur in einfachen Zusammenhängen verwenden, wählen wir den pragmatischen Einsatz.

Low-Level-Modell Vorteile Nachteile

Eine Variable wird wie im Maschinecode/Assembler als ein reservierter Hauptspeicherplatz angesehen, der über seine Adresse angesprochen wird

Anschaulicher Bezug zur Maschinenstruktur
Adressen sind zwar im Assembler,  C/C++ und anderen Programmiersprachen mit Zeigern (Pointer) wichtig,  spielen aber in in der Praxis bei vielen anderen Programmiersprachen nur noch eine untergeordnete Rolle oder sind sogar verpönt

Boxmetapher Vorteile Nachteile
Eine Variable wird als eine Box- (oder Schublade) aufgefasst, die mit einem Namen angeschrieben ist und in der sich der Wert befindet
Eine Variable wird als eine Box- (oder Schublade) aufgefasst, die mit einem Namen angeschrieben ist und in der sich der Wert befindet
Die Box kann auch leer sein, eine Variable hat aber immer einen Wert. Die Box kann auch mehrere Dinge enthalten, eine Variable aber nicht.

Das Boxmetapher ist für Python falsch, da eine Variable hier immer eine Referenz auf ein Objekt ist (auch für Zahlen)

Pragmatischer Ansatz Vorteile Nachteile

Variablen sind Bezeichner für einen Wert, der verändert werden kann. Es gibt also einen Bezug oder eine Verbindung (engl. bindung) zwischen dem Namen (Alias) und ihrem Wert (der irgendein Datentyp sein kann)

Der Ansatz entspricht der intuitiven Auffassung von Namen:
"Hans ist ein Bezeichner für eine Person".
Man "verliert" keine Zeit mit problematischen Erklärungen
Man bleibt vage, was die Implementierung der Variablen (das Speichermodell) angeht