crahCourse
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 sichtbaren Käfer in der Mitte des Displays. Es ist nur eine 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 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()
► In Zwischenablage kopieren

 
Du kannst das Programm eintippen oder aus der Zwischenablage einfügen. Dazu klickst du auf In Zwischenablage kopieren 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).

  


Falls du mit dem Online-Editor arbeitest, klickst du auf Online-Editor. Das Programm wird danach automatisch in das Editorfenster eingeführt.

 

 

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)
► In Zwischenablage kopieren

 

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

makeGlow()

setPos(-2, -2)
repeat 4:
    repeat 4:
        forward()
    right(90)
► In Zwischenablage kopieren

 

 

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, das 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.I

from mbglow import *

makeGlow()

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

square()
► In Zwischenablage kopieren


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

makeGlow()

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

setSpeed(80)
repeat 4:
    square()
    right(90)
► In Zwischenablage kopieren

 

 

VARIABLEN
 

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

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 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
► In Zwischenablage kopieren

 

 

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

makeGlow()

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


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()
► In Zwischenablage kopieren

 

 

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

makeGlow()

clear()
for x in range(-2, 3):
    setPos(x, 2)
    sleep(500)
► In Zwischenablage kopieren

 

 

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
► In Zwischenablage kopieren

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 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 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)
► In Zwischenablage kopieren

 

 

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.

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 ein Pluszeichen zeichnet.  

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, also ein Kreuz zeichnet.

  

4.

So wie im ersten Beispiel zu 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, aber nur LEDs gemäss der nebenstehenden Figur eingeschalten.

  

6.

Dein Programm soll LEDs gemäss der nebenstehenden "Schachbrett"-Figur einschalten. Wie du leicht einsiehst erfüllen die leuchtenden LEDs Bedingung: 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 Ganzzahldivision von a durch b liefert. Eine Zahl a ist also gerade, wenn a % 2 == 0 ist.

  
 

 

 

   

 

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